cypress

  • Version 13.12.0
  • Published
  • 7.19 MB
  • 42 dependencies
  • MIT license

Install

npm i cypress
yarn add cypress
pnpm add cypress

Overview

Cypress is a next generation front end testing tool built for the modern web

Index

Namespaces

Namespaces

namespace chai

module 'chai' {}

    variable chai

    const chai: Chai.ChaiStatic;

      namespace cypress

      module 'cypress' {}

        variable cypress

        const cypress: CypressNpmApi;

          namespace Cypress

          namespace Cypress {}

            interface ActionableOptions

            interface ActionableOptions extends Forceable {}
            • Options to affect Actionability checks

              See Also

              • https://on.cypress.io/interacting-with-elements#Actionability

            property animationDistanceThreshold

            animationDistanceThreshold: number;
            • The distance in pixels an element must exceed over time to be considered animating

              5

            property scrollBehavior

            scrollBehavior: scrollBehaviorOptions;
            • Viewport position to which an element should be scrolled prior to action commands. Setting false disables scrolling.

              'top'

            property waitForAnimations

            waitForAnimations: boolean;
            • Whether to wait for elements to finish animating before executing commands

              true

            interface Actions

            interface Actions {}
            • These events come from the application currently under test (your application). These are the most useful events for you to listen to.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'uncaught:exception',
            fn: (
            error: Error,
            runnable: Mocha.Runnable,
            promise?: Promise<any>
            ) => false | void
            ): Cypress;
            • Fires when an uncaught exception or unhandled rejection occurs in your application. If it's an unhandled rejection, the rejected promise will be the 3rd argument. Cypress will fail the test when this fires. Return false from this event and Cypress will not fail the test. Also useful for debugging purposes because the actual error instance is provided to you.

              Example 1

              ``` // likely want to do this in a support file // so it's applied to all spec files // cypress/support/{e2e|component}.js

              Cypress.on('uncaught:exception', (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) // trigger application code that calls alert(...) .then(() => { expect(stub).to.have.been.calledOnce }) }) ```

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'window:confirm',
            fn:
            | ((text: string) => false | void)
            | SinonSpyAgent<sinon.SinonSpy>
            | SinonSpyAgent<sinon.SinonStub>
            ): Cypress;
            • 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 canceled.

              Example 1

              ``` cy.on('window:confirm', (str) => { console.log(str) return false // simulate "Cancel" }) ```

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'scrolled', fn: ($el: JQuery) => void): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'command:enqueued',
            fn: (command: EnqueuedCommandAttributes) => void
            ): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'command:start', fn: (command: CommandQueue) => void): Cypress;
            • Fires when cy begins actually running and executing your command. Useful for debugging and understanding how the command queue is async.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'command:end', fn: (command: CommandQueue) => void): Cypress;
            • Fires when cy finishes running and executing your command. Useful for debugging and understanding how commands are handled.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'skipped:command:end', fn: (command: CommandQueue) => void): Cypress;
            • Fires when a command is skipped, namely the should command. Useful for debugging and understanding how commands are handled.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'command:retry', fn: (command: CommandQueue) => void): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'log:added', fn: (attributes: ObjectLike, log: any) => void): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'log:changed', fn: (attributes: ObjectLike, log: any) => void): Cypress;
            • Fires whenever a command's attributes changes. This event is debounced to prevent it from firing too quickly and too often. Useful to see how internal cypress commands utilize the {% url 'Cypress.log()' cypress-log %} API.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'test:before:run',
            fn: (attributes: ObjectLike, test: Mocha.Test) => void
            ): Cypress;
            • Fires before the test and all **before** and **beforeEach** hooks run.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'test:before:run:async',
            fn: (attributes: ObjectLike, test: Mocha.Test) => void | Promise<any>
            ): Cypress;
            • Fires before the test and all **before** and **beforeEach** hooks run. If a Promise is returned, it will be awaited before proceeding.

            call signature

            (
            action: 'window:alert',
            fn:
            | ((text: string) => void)
            | SinonSpyAgent<sinon.SinonSpy>
            | SinonSpyAgent<sinon.SinonStub>
            ): Cypress;
            • Fires when your app calls the global window.alert() method. Cypress will auto accept alerts. You cannot change this behavior.

              Example 1

              ``` const stub = cy.stub() cy.on('window:alert', stub) // assume the button calls window.alert() cy.get('.my-button') .click() .then(() => { expect(stub).to.have.been.calledOnce }) ```

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'test:after:run',
            fn: (attributes: ObjectLike, test: Mocha.Test) => void
            ): Cypress;
            • Fires after the test and all **afterEach** and **after** hooks run.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'window:before:load', fn: (win: AUTWindow) => void): Cypress;
            • 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.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'window:load', fn: (win: AUTWindow) => void): Cypress;
            • 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.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'window:before:unload',
            fn: (event: BeforeUnloadEvent) => void
            ): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'window:unload', fn: (event: Event) => void): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'url:changed', fn: (url: string) => void): Cypress;
            • Fires whenever Cypress detects that your application's URL has changed.

              See Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (
            action: 'fail',
            fn: (error: CypressError, mocha: Mocha.Runnable) => void
            ): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            call signature

            (action: 'viewport:changed', fn: (viewport: Viewport) => void): Cypress;
            • 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 Also

              • https://on.cypress.io/catalog-of-events#App-Events

            interface AfterBrowserLaunchDetails

            interface AfterBrowserLaunchDetails {}

              property webSocketDebuggerUrl

              webSocketDebuggerUrl: string;

                interface AfterScreenshotReturnObject

                interface AfterScreenshotReturnObject {}

                  property dimensions

                  dimensions?: Dimensions;

                    property path

                    path?: string;

                      property size

                      size?: number;

                        interface AngularDevServerProjectConfig

                        interface AngularDevServerProjectConfig {}

                          property buildOptions

                          buildOptions: Record<string, any>;

                            property root

                            root: string;

                              property sourceRoot

                              sourceRoot: string;

                                interface ApplicationWindow

                                interface ApplicationWindow {}
                                • The interface for user-defined properties in Window object under test.

                                interface AsOptions

                                interface AsOptions {}
                                • Options to affect how an alias is stored

                                  See Also

                                  • https://on.cypress.io/as

                                property type

                                type: 'query' | 'static';
                                • The type of alias to store, which impacts how the value is retrieved later in the test. If an alias should be a 'query' (re-runs all queries leading up to the resulting value so it's alway up-to-date) or a 'static' (read once when the alias is saved and is never updated). type has no effect when aliasing intercepts, spies, and stubs.

                                  'query'

                                interface Auth

                                interface Auth {}

                                  property password

                                  password: string;

                                    property username

                                    username: string;

                                      interface Backend

                                      interface Backend {}

                                        call signature

                                        (task: 'firefox:force:gc'): Promise<void>;
                                        • Firefox only: Force Cypress to run garbage collection routines. No-op if not running in Firefox.

                                          See Also

                                          • https://on.cypress.io/firefox-gc-issue

                                        call signature

                                        (task: 'net', eventName: string, frame: any): Promise<void>;

                                          interface BeforeBrowserLaunchOptions

                                          interface BeforeBrowserLaunchOptions {}

                                            property args

                                            args: string[];

                                              property env

                                              env: { [key: string]: any };

                                                property extensions

                                                extensions: string[];

                                                  property preferences

                                                  preferences: { [key: string]: any };

                                                    interface BeforeRunDetails

                                                    interface BeforeRunDetails {}

                                                      property autoCancelAfterFailures

                                                      autoCancelAfterFailures?: number | false;

                                                        property browser

                                                        browser?: Browser;

                                                          property config

                                                          config: ConfigOptions;

                                                            property cypressVersion

                                                            cypressVersion: string;

                                                              property group

                                                              group?: string;

                                                                property parallel

                                                                parallel?: boolean;

                                                                  property runUrl

                                                                  runUrl?: string;

                                                                    property specPattern

                                                                    specPattern?: string[];

                                                                      property specs

                                                                      specs?: Spec[];

                                                                        property system

                                                                        system: SystemDetails;

                                                                          property tag

                                                                          tag?: string;

                                                                            interface BlurOptions

                                                                            interface BlurOptions extends Loggable, Timeoutable, Forceable {}

                                                                              interface Browser

                                                                              interface Browser {}
                                                                              • Describes a browser Cypress can control

                                                                              property channel

                                                                              channel: BrowserChannel;
                                                                              • The release channel of the browser.

                                                                              property displayName

                                                                              displayName: string;
                                                                              • Human-readable browser name.

                                                                              property family

                                                                              family: BrowserFamily;
                                                                              • The underlying engine for this browser.

                                                                              property info

                                                                              info?: string;
                                                                              • Informational text to accompany this browser. Shown in desktop-gui.

                                                                              property isHeaded

                                                                              isHeaded: boolean;

                                                                                property isHeadless

                                                                                isHeadless: boolean;

                                                                                  property majorVersion

                                                                                  majorVersion: number | string;

                                                                                    property minSupportedVersion

                                                                                    minSupportedVersion?: number;
                                                                                    • The minimum majorVersion of this browser supported by Cypress.

                                                                                    property name

                                                                                    name: BrowserName;
                                                                                    • Short browser name.

                                                                                    property path

                                                                                    path: string;

                                                                                      property unsupportedVersion

                                                                                      unsupportedVersion?: boolean;
                                                                                      • If true, this browser is too old to be supported by Cypress.

                                                                                      property version

                                                                                      version: string;

                                                                                        property warning

                                                                                        warning?: string;
                                                                                        • Warning text to accompany this browser. Shown in desktop-gui.

                                                                                        interface CaseMatchable

                                                                                        interface CaseMatchable {}
                                                                                        • Options that check case sensitivity

                                                                                        property matchCase

                                                                                        matchCase: boolean;
                                                                                        • Check case sensitivity

                                                                                          true

                                                                                        interface Chainable

                                                                                        interface Chainable<Subject = any> {}
                                                                                        • Chainable interface for non-array Subjects

                                                                                        property and

                                                                                        and: Chainer<Subject>;
                                                                                        • Create an assertion. Assertions are automatically retried until they pass or time out.

                                                                                          should

                                                                                          See Also

                                                                                          • https://on.cypress.io/and

                                                                                        property off

                                                                                        off: Actions;
                                                                                        • These events come from Cypress as it issues commands and reacts to their state. These are all useful to listen to for debugging purposes.

                                                                                          See Also

                                                                                          • https://on.cypress.io/catalog-of-events#App-Events

                                                                                        property on

                                                                                        on: Actions;
                                                                                        • These events come from Cypress as it issues commands and reacts to their state. These are all useful to listen to for debugging purposes.

                                                                                          See Also

                                                                                          • https://on.cypress.io/catalog-of-events#App-Events

                                                                                        property once

                                                                                        once: Actions;
                                                                                        • These events come from Cypress as it issues commands and reacts to their state. These are all useful to listen to for debugging purposes.

                                                                                          See Also

                                                                                          • https://on.cypress.io/catalog-of-events#App-Events

                                                                                        property should

                                                                                        should: Chainer<Subject>;
                                                                                        • Create an assertion. Assertions are automatically retried until they pass or time out.

                                                                                          Example 1

                                                                                          // Assert on the href of the location cy.location('href').should('contain', '/tag/tutorials/')

                                                                                          See Also

                                                                                          • https://on.cypress.io/should

                                                                                        method $$

                                                                                        $$: <TElement extends Element = HTMLElement>(
                                                                                        selector: JQuery.Selector,
                                                                                        context?: Element | Document | JQuery
                                                                                        ) => JQuery<TElement>;
                                                                                        • jQuery library bound to the AUT

                                                                                          Example 1

                                                                                          cy.$$('p')

                                                                                          See Also

                                                                                          • https://on.cypress.io/$

                                                                                        method as

                                                                                        as: (alias: string, options?: Partial<AsOptions>) => Chainable<Subject>;
                                                                                        • Assign an alias for later use. Reference the alias later within a [cy.get()](https://on.cypress.io/get) or [cy.wait()](https://on.cypress.io/wait) command with a @ prefix. You can alias DOM elements, routes, stubs and spies.

                                                                                          Example 1

                                                                                          // Get the aliased 'todos' elements cy.get('ul#todos').as('todos')

                                                                                          // later retrieve the todos cy.get('@todos')

                                                                                          See Also

                                                                                          • https://on.cypress.io/as

                                                                                          • https://on.cypress.io/variables-and-aliases

                                                                                          • https://on.cypress.io/get

                                                                                        method blur

                                                                                        blur: (options?: Partial<BlurOptions>) => Chainable<Subject>;
                                                                                        • Blur a focused element. This element must currently be in focus. If you want to ensure an element is focused before blurring, try using .focus() before .blur().

                                                                                          See Also

                                                                                          • https://on.cypress.io/blur

                                                                                        method check

                                                                                        check: {
                                                                                        (options?: Partial<CheckOptions>): Chainable<Subject>;
                                                                                        (
                                                                                        value: string | string[],
                                                                                        options?: Partial<CheckOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Check checkbox(es) or radio(s). This element must be an <input> with type checkbox or radio.

                                                                                          Example 1

                                                                                          // Check checkbox element cy.get('[type="checkbox"]').check() // Check first radio element cy.get('[type="radio"]').first().check()

                                                                                          See Also

                                                                                          • https://on.cypress.io/check

                                                                                        • Check checkbox(es) or radio(s). This element must be an <input> with type checkbox or radio.

                                                                                          Example 1

                                                                                          // Select the radio with the value of 'US' cy.get('[type="radio"]').check('US') // Check the checkboxes with the values 'ga' and 'ca' cy.get('[type="checkbox"]').check(['ga', 'ca'])

                                                                                          See Also

                                                                                          • https://on.cypress.io/check

                                                                                        method children

                                                                                        children: {
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the children of each DOM element within a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/children

                                                                                        method clear

                                                                                        clear: (options?: Partial<ClearOptions>) => Chainable<Subject>;
                                                                                        • Clear the value of an input or textarea. An alias for .type({selectall}{del})

                                                                                          See Also

                                                                                          • https://on.cypress.io/clear

                                                                                        method clearAllCookies

                                                                                        clearAllCookies: (options?: Partial<Loggable & Timeoutable>) => Chainable<null>;
                                                                                        • Clear all browser cookies.

                                                                                          Cypress automatically clears all cookies _before_ each test to prevent state from being shared across tests when test isolation is enabled. You shouldn't need to use this command unless you're using it to clear all cookie inside a single test or test isolation is disabled.

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearallcookies

                                                                                        method clearAllLocalStorage

                                                                                        clearAllLocalStorage: (options?: Partial<Loggable>) => Chainable<null>;
                                                                                        • Clear local storage for all origins.

                                                                                          Cypress automatically clears all local storage _before_ each test to prevent state from being shared across tests when test isolation is enabled. You shouldn't need to use this command unless you're using it to clear localStorage inside a single test or test isolation is disabled.

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearalllocalstorage

                                                                                        method clearAllSessionStorage

                                                                                        clearAllSessionStorage: (options?: Partial<Loggable>) => Chainable<null>;
                                                                                        • Clear session storage for all origins.

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearallsessionstorage

                                                                                        method clearCookie

                                                                                        clearCookie: (name: string, options?: CookieOptions) => Chainable<null>;
                                                                                        • Clear a specific browser cookie for a domain.

                                                                                          Cypress automatically clears all cookies _before_ each test to prevent state from being shared across tests when test isolation is enabled. You shouldn't need to use this command unless you're using it to clear a specific cookie inside a single test or test isolation is disabled.

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearcookie

                                                                                        method clearCookies

                                                                                        clearCookies: (options?: CookieOptions) => Chainable<null>;
                                                                                        • Clear browser cookies for a domain.

                                                                                          Cypress automatically clears all cookies _before_ each test to prevent state from being shared across tests when test isolation is enabled. You shouldn't need to use this command unless you're using it to clear specific cookies inside a single test or test isolation is disabled.

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearcookies

                                                                                        method clearLocalStorage

                                                                                        clearLocalStorage: {
                                                                                        (key?: string): Chainable<Storage>;
                                                                                        (re: RegExp): Chainable<Storage>;
                                                                                        (options: Partial<Loggable>): Chainable<Storage>;
                                                                                        (key: string, options: Partial<Loggable>): Chainable<Storage>;
                                                                                        };
                                                                                        • Clear data in local storage for the current origin.

                                                                                          Cypress automatically clears all local storage _before_ each test to prevent state from being shared across tests when test isolation is enabled. You shouldn't need to use this command unless you're using it to clear localStorage inside a single test or test isolation is disabled.

                                                                                          Parameter key

                                                                                          name of a particular item to remove (optional).

                                                                                          Example 1

                                                                                          ``` // Removes all local storage keys cy.clearLocalStorage() .should(ls => { expect(ls.getItem('prop1')).to.be.null }) // Removes item "todos" cy.clearLocalStorage("todos") ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearlocalstorage

                                                                                        • Clear keys in local storage that match given regular expression.

                                                                                          Parameter re

                                                                                          regular expression to match.

                                                                                          Example 1

                                                                                          ``` // Clears all local storage matching /app-/ cy.clearLocalStorage(/app-/) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearlocalstorage

                                                                                        • Clear data in local storage. Cypress automatically runs this command before each test to prevent state from being shared across tests. You shouldn't need to use this command unless you're using it to clear localStorage inside a single test. Yields localStorage object.

                                                                                          Parameter object

                                                                                          options object

                                                                                          Example 1

                                                                                          ``` // Removes all local storage items, without logging cy.clearLocalStorage({ log: false }) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearlocalstorage

                                                                                        • Clear data in local storage. Cypress automatically runs this command before each test to prevent state from being shared across tests. You shouldn't need to use this command unless you're using it to clear localStorage inside a single test. Yields localStorage object.

                                                                                          Parameter key

                                                                                          name of a particular item to remove (optional).

                                                                                          Parameter object

                                                                                          options object

                                                                                          Example 1

                                                                                          ``` // Removes item "todos" without logging cy.clearLocalStorage("todos", { log: false }) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/clearlocalstorage

                                                                                        method click

                                                                                        click: {
                                                                                        (options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        (
                                                                                        position: PositionType,
                                                                                        options?: Partial<ClickOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        (x: number, y: number, options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        };
                                                                                        • Click a DOM element.

                                                                                          Example 1

                                                                                          cy.get('button').click() // Click on button cy.focused().click() // Click on el with focus cy.contains('Welcome').click() // Click on first el containing 'Welcome'

                                                                                          See Also

                                                                                          • https://on.cypress.io/click

                                                                                        • Click a DOM element at specific corner / side.

                                                                                          Parameter position

                                                                                          The position where the click should be issued. The center position is the default position.

                                                                                          Example 1

                                                                                          cy.get('button').click('topRight')

                                                                                          See Also

                                                                                          • https://on.cypress.io/click

                                                                                        • Click a DOM element at specific coordinates

                                                                                          Parameter x

                                                                                          The distance in pixels from the element's left to issue the click.

                                                                                          Parameter y

                                                                                          The distance in pixels from the element's top to issue the click.

                                                                                          Example 1

                                                                                          ``` // The click below will be issued inside of the element // (15px from the left and 40px from the top). cy.get('button').click(15, 40) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/click

                                                                                        method clock

                                                                                        clock: {
                                                                                        (): Chainable<Clock>;
                                                                                        (now: number | Date, options?: Loggable): Chainable<Clock>;
                                                                                        (
                                                                                        now: number | Date,
                                                                                        functions?: (
                                                                                        | 'setTimeout'
                                                                                        | 'clearTimeout'
                                                                                        | 'setInterval'
                                                                                        | 'clearInterval'
                                                                                        | 'Date'
                                                                                        )[],
                                                                                        options?: Loggable
                                                                                        ): Chainable<Clock>;
                                                                                        (options: Loggable): Chainable<Clock>;
                                                                                        };
                                                                                        • cy.clock() overrides native global functions related to time allowing them to be controlled synchronously via [cy.tick()](https://on.cypress.io/tick) or the yielded clock object. This includes controlling: * setTimeout * clearTimeout * setInterval * clearInterval * Date Objects

                                                                                          The clock starts at the unix epoch (timestamp of 0). This means that when you instantiate new Date in your application, it will have a time of January 1st, 1970.

                                                                                          To restore the real clock call .restore()

                                                                                          Example 1

                                                                                          cy.clock() ... // restore the application clock cy.clock().then(clock => { clock.restore() }) // or use this shortcut cy.clock().invoke('restore')

                                                                                          See Also

                                                                                          • https://on.cypress.io/clock

                                                                                        • Mocks global clock and sets current timestamp to the given value. Overrides all functions that deal with time.

                                                                                          Example 1

                                                                                          // in your app code $('#date').text(new Date().toJSON()) // in the spec file // March 14, 2017 timestamp or Date object const now = new Date(2017, 2, 14).getTime() cy.clock(now) cy.visit('/index.html') cy.get('#date').contains('2017-03-14') // to restore the real clock cy.clock().then(clock => { clock.restore() }) // or use this shortcut cy.clock().invoke('restore')

                                                                                          See Also

                                                                                          • https://on.cypress.io/clock

                                                                                        • Mocks global clock but only overrides specific functions.

                                                                                          Example 1

                                                                                          // keep current date but override "setTimeout" and "clearTimeout" cy.clock(null, ['setTimeout', 'clearTimeout'])

                                                                                          See Also

                                                                                          • https://on.cypress.io/clock

                                                                                        • Mocks global clock and all functions.

                                                                                          Example 1

                                                                                          // mock clock but do not log this command cy.clock({ log: false })

                                                                                          See Also

                                                                                          • https://on.cypress.io/clock

                                                                                        method closest

                                                                                        closest: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the first DOM element that matches the selector (whether it be itself or one of its ancestors).

                                                                                          See Also

                                                                                          • https://on.cypress.io/closest

                                                                                        method contains

                                                                                        contains: {
                                                                                        (
                                                                                        content: string | number | RegExp,
                                                                                        options?: Partial<Loggable & Timeoutable & CaseMatchable & Shadow>
                                                                                        ): Chainable<Subject>;
                                                                                        <E extends Node = HTMLElement>(content: string | number | RegExp): Chainable<
                                                                                        JQuery<E>
                                                                                        >;
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        text: string | number | RegExp,
                                                                                        options?: Partial<Loggable & Timeoutable & CaseMatchable & Shadow>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        text: string | number | RegExp,
                                                                                        options?: Partial<Loggable & Timeoutable & CaseMatchable & Shadow>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the DOM element containing the text. DOM elements can contain more than the desired text and still match. Additionally, Cypress prefers some DOM elements over the deepest element found.

                                                                                          Example 1

                                                                                          // Yield el in .nav containing 'About' cy.get('.nav').contains('About') // Yield first el in document containing 'Hello' cy.contains('Hello') // you can use regular expression cy.contains(/^b\w+/) // yields ... cy.contains('ul', 'apples') // tries to find the given text for up to 1 second cy.contains('my text to find', {timeout: 1000})

                                                                                          See Also

                                                                                          • https://on.cypress.io/contains

                                                                                        • Get the child DOM element that contains given text.

                                                                                          Example 1

                                                                                          // Yield el in .nav containing 'About' cy.get('.nav').contains('About')

                                                                                          See Also

                                                                                          • https://on.cypress.io/contains

                                                                                        • Get the DOM element with name "selector" containing the text or regular expression.

                                                                                          Example 1

                                                                                          // yields ... cy.contains('ul', 'apples')

                                                                                          See Also

                                                                                          • https://on.cypress.io/contains

                                                                                        • Get the DOM element using CSS "selector" containing the text or regular expression.

                                                                                          Example 1

                                                                                          // yields <... class="foo">... apples ...</...> cy.contains('.foo', 'apples')

                                                                                          See Also

                                                                                          • https://on.cypress.io/contains

                                                                                        method dblclick

                                                                                        dblclick: {
                                                                                        (options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        (
                                                                                        position: PositionType,
                                                                                        options?: Partial<ClickOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        (x: number, y: number, options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        };
                                                                                        • Double-click a DOM element.

                                                                                          See Also

                                                                                          • https://on.cypress.io/dblclick

                                                                                        • Double-click a DOM element at specific corner / side.

                                                                                          Parameter position

                                                                                          The position where the click should be issued. The center position is the default position.

                                                                                          Example 1

                                                                                          cy.get('button').dblclick('topRight')

                                                                                          See Also

                                                                                          • https://on.cypress.io/dblclick

                                                                                        • Double-click a DOM element at specific coordinates

                                                                                          Parameter x

                                                                                          The distance in pixels from the element's left to issue the click.

                                                                                          Parameter y

                                                                                          The distance in pixels from the element's top to issue the click.

                                                                                          Example 1

                                                                                          ``` // The click below will be issued inside of the element // (15px from the left and 40px from the top). cy.get('button').dblclick(15, 40) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/dblclick

                                                                                        method debug

                                                                                        debug: (options?: Partial<Loggable>) => Chainable<Subject>;
                                                                                        • Set a debugger and log what the previous command yields.

                                                                                          See Also

                                                                                          • https://on.cypress.io/debug

                                                                                        method document

                                                                                        document: (options?: Partial<Loggable & Timeoutable>) => Chainable<Document>;
                                                                                        • Get the window.document of the page that is currently active.

                                                                                          Example 1

                                                                                          cy.document() .its('contentType') .should('eq', 'text/html')

                                                                                          See Also

                                                                                          • https://on.cypress.io/document

                                                                                        method each

                                                                                        each: {
                                                                                        <E extends Node = HTMLElement>(
                                                                                        fn: (element: JQuery<E>, index: number, $list: E[]) => void
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        (fn: (item: any, index: number, $list: any[]) => void): Chainable<Subject>;
                                                                                        };
                                                                                        • Iterate through an array like structure (arrays or objects with a length property).

                                                                                          See Also

                                                                                          • https://on.cypress.io/each

                                                                                        method end

                                                                                        end: () => Chainable<null>;
                                                                                        • End a chain of commands

                                                                                          See Also

                                                                                          • https://on.cypress.io/end

                                                                                        method eq

                                                                                        eq: <E extends Node = HTMLElement>(
                                                                                        index: number,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<JQuery<E>>;
                                                                                        • Get A DOM element at a specific index in an array of elements.

                                                                                          Parameter index

                                                                                          A number indicating the index to find the element at within an array of elements. A negative number counts index from the end of the list.

                                                                                          Example 1

                                                                                          cy.get('tbody>tr').eq(0) // Yield first 'tr' in 'tbody' cy.get('ul>li').eq('4') // Yield fifth 'li' in 'ul' cy.get('li').eq(-2) // Yields second from last 'li' element

                                                                                          See Also

                                                                                          • https://on.cypress.io/eq

                                                                                        method exec

                                                                                        exec: (command: string, options?: Partial<ExecOptions>) => Chainable<Exec>;
                                                                                        • Execute a system command.

                                                                                          See Also

                                                                                          • https://on.cypress.io/exec

                                                                                        method filter

                                                                                        filter: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        fn: (index: number, element: E) => boolean,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the DOM elements that match a specific selector. Opposite of .not()

                                                                                          See Also

                                                                                          • https://on.cypress.io/filter

                                                                                        method find

                                                                                        find: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable & Shadow>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable & Shadow>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the descendent DOM elements of a specific selector.

                                                                                          Example 1

                                                                                          cy.get('.article').find('footer') // Yield 'footer' within '.article'

                                                                                          See Also

                                                                                          • https://on.cypress.io/find

                                                                                        • Finds the descendent DOM elements with the given selector.

                                                                                          Example 1

                                                                                          // Find the li's within the nav cy.get('.left-nav>.nav').find('>li')

                                                                                          See Also

                                                                                          • https://on.cypress.io/find

                                                                                        method first

                                                                                        first: (options?: Partial<Loggable & Timeoutable>) => Chainable<Subject>;
                                                                                        • Get the first DOM element within a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/first

                                                                                        method fixture

                                                                                        fixture: {
                                                                                        <Contents = any>(
                                                                                        path: string,
                                                                                        options?: Partial<Timeoutable>
                                                                                        ): Chainable<Contents>;
                                                                                        <Contents = any>(
                                                                                        path: string,
                                                                                        encoding: Encodings,
                                                                                        options?: Partial<Timeoutable>
                                                                                        ): Chainable<Contents>;
                                                                                        };
                                                                                        • Load a fixed set of data located in a file.

                                                                                          See Also

                                                                                          • https://on.cypress.io/fixture

                                                                                        • Load a fixed set of data located in a file with given encoding.

                                                                                          See Also

                                                                                          • https://on.cypress.io/fixture

                                                                                        method focus

                                                                                        focus: (options?: Partial<Loggable & Timeoutable>) => Chainable<Subject>;
                                                                                        • Focus on a DOM element.

                                                                                          Example 1

                                                                                          cy.get('input').first().focus() // Focus on the first input

                                                                                          See Also

                                                                                          • https://on.cypress.io/focus

                                                                                        method focused

                                                                                        focused: (options?: Partial<Loggable & Timeoutable>) => Chainable<JQuery>;
                                                                                        • Get the DOM element that is currently focused.

                                                                                          Example 1

                                                                                          // Get the element that is focused cy.focused().then(function($el) { // do something with $el }) // Blur the element with focus cy.focused().blur() // Make an assertion on the focused element cy.focused().should('have.attr', 'name', 'username')

                                                                                          See Also

                                                                                          • https://on.cypress.io/focused

                                                                                        method get

                                                                                        get: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable & Withinable & Shadow>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable & Withinable & Shadow>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <S = any>(
                                                                                        alias: string,
                                                                                        options?: Partial<Loggable & Timeoutable & Withinable & Shadow>
                                                                                        ): Chainable<S>;
                                                                                        };
                                                                                        • Get one or more DOM elements by node name: input, button, etc.

                                                                                          Example 1

                                                                                          cy.get('input').should('be.disabled') cy.get('button').should('be.visible')

                                                                                          See Also

                                                                                          • https://on.cypress.io/get

                                                                                        • Get one or more DOM elements by selector. The querying behavior of this command matches exactly how $(…) works in jQuery.

                                                                                          Example 1

                                                                                          cy.get('.list>li') // Yield the 's in <.list> cy.get('ul li:first').should('have.class', 'active') cy.get('.dropdown-menu').click()

                                                                                          See Also

                                                                                          • https://on.cypress.io/get

                                                                                        • Get one or more DOM elements by alias.

                                                                                          Example 1

                                                                                          // Get the aliased 'todos' elements cy.get('ul#todos').as('todos') //...hack hack hack... //later retrieve the todos cy.get('@todos')

                                                                                          See Also

                                                                                          • https://on.cypress.io/get#Alias

                                                                                        method getAllCookies

                                                                                        getAllCookies: (
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<Cookie[]>;
                                                                                        • Get all browser cookies.

                                                                                          See Also

                                                                                          • https://on.cypress.io/getallcookies

                                                                                        method getAllLocalStorage

                                                                                        getAllLocalStorage: (options?: Partial<Loggable>) => Chainable<StorageByOrigin>;
                                                                                        • Get local storage for all origins.

                                                                                          See Also

                                                                                          • https://on.cypress.io/getalllocalstorage

                                                                                        method getAllSessionStorage

                                                                                        getAllSessionStorage: (
                                                                                        options?: Partial<Loggable>
                                                                                        ) => Chainable<StorageByOrigin>;
                                                                                        • Get session storage for all origins.

                                                                                          See Also

                                                                                          • https://on.cypress.io/getallsessionstorage

                                                                                        method getCookie

                                                                                        getCookie: (name: string, options?: CookieOptions) => Chainable<Cookie | null>;
                                                                                        • Get a browser cookie by its name.

                                                                                          See Also

                                                                                          • https://on.cypress.io/getcookie

                                                                                        method getCookies

                                                                                        getCookies: (options?: CookieOptions) => Chainable<Cookie[]>;
                                                                                        • Get browser cookies for a domain.

                                                                                          See Also

                                                                                          • https://on.cypress.io/getcookies

                                                                                        method go

                                                                                        go: (
                                                                                        direction: HistoryDirection | number,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<AUTWindow>;
                                                                                        • Navigate back or forward to the previous or next URL in the browser's history.

                                                                                          See Also

                                                                                          • https://on.cypress.io/go

                                                                                        method hash

                                                                                        hash: (options?: Partial<Loggable & Timeoutable>) => Chainable<string>;
                                                                                        • Get the current URL hash of the page that is currently active.

                                                                                          See Also

                                                                                          • https://on.cypress.io/hash

                                                                                        method invoke

                                                                                        invoke: {
                                                                                        <
                                                                                        K extends keyof Subject,
                                                                                        F extends ((...args: any[]) => any) & Subject[K],
                                                                                        R = ReturnType<F>
                                                                                        >(
                                                                                        functionName: K,
                                                                                        ...args: any[]
                                                                                        ): Chainable<R>;
                                                                                        <
                                                                                        K extends keyof Subject,
                                                                                        F extends ((...args: any[]) => any) & Subject[K],
                                                                                        R = ReturnType<F>
                                                                                        >(
                                                                                        options: Partial<Loggable & Timeoutable>,
                                                                                        functionName: K,
                                                                                        ...args: any[]
                                                                                        ): Chainable<R>;
                                                                                        <T extends (...args: any[]) => any, Subject extends T[]>(
                                                                                        index: number
                                                                                        ): Chainable<ReturnType<T>>;
                                                                                        <T extends (...args: any[]) => any, Subject extends T[]>(
                                                                                        options: Partial<Loggable & Timeoutable>,
                                                                                        index: number
                                                                                        ): Chainable<ReturnType<T>>;
                                                                                        (propertyPath: string, ...args: any[]): Chainable<any>;
                                                                                        };
                                                                                        • Invoke a function on the previously yielded subject.

                                                                                          See Also

                                                                                          • https://on.cypress.io/invoke

                                                                                        • Invoke a function in an array of functions.

                                                                                          See Also

                                                                                          • https://on.cypress.io/invoke

                                                                                        • Invoke a function on the previously yielded subject by a property path. Property path invocation cannot be strongly-typed. Invoking by a property path will always result in any.

                                                                                          See Also

                                                                                          • https://on.cypress.io/invoke

                                                                                        method its

                                                                                        its: {
                                                                                        <K extends keyof Subject>(
                                                                                        propertyName: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<NonNullable<Subject[K]>>;
                                                                                        (
                                                                                        propertyPath: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<any>;
                                                                                        <T, Subject extends T[]>(
                                                                                        index: number,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<T>;
                                                                                        };
                                                                                        • Get a property's value on the previously yielded subject.

                                                                                          Example 1

                                                                                          // Get the 'width' property cy.wrap({width: '50'}).its('width') // Drill into nested properties by using dot notation cy.wrap({foo: {bar: {baz: 1}}}).its('foo.bar.baz')

                                                                                          See Also

                                                                                          • https://on.cypress.io/its

                                                                                        • Get a value by index from an array yielded from the previous command.

                                                                                          Example 1

                                                                                          cy.wrap(['a', 'b']).its(1).should('equal', 'b')

                                                                                          See Also

                                                                                          • https://on.cypress.io/its

                                                                                        method last

                                                                                        last: <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<JQuery<E>>;
                                                                                        • Get the last DOM element within a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/last

                                                                                        method location

                                                                                        location: {
                                                                                        (options?: Partial<Loggable & Timeoutable>): Chainable<Location>;
                                                                                        <K extends keyof Location>(
                                                                                        key: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<Location[K]>;
                                                                                        };
                                                                                        • Get the global window.location object of the page that is currently active.

                                                                                          Example 1

                                                                                          cy.location() // Get location object

                                                                                          See Also

                                                                                          • https://on.cypress.io/location

                                                                                        • Get a part of the global window.location object of the page that is currently active.

                                                                                          Example 1

                                                                                          cy.location('host') // Get the host of the location object cy.location('port') // Get the port of the location object // Assert on the href of the location cy.location('href').should('contain', '/tag/tutorials')

                                                                                          See Also

                                                                                          • https://on.cypress.io/location

                                                                                        method log

                                                                                        log: (message: string, ...args: any[]) => Chainable<null>;
                                                                                        • Print a message to the Cypress Command Log.

                                                                                          See Also

                                                                                          • https://on.cypress.io/log

                                                                                        method next

                                                                                        next: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the immediately following sibling of each DOM element within a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/next

                                                                                        • Get the immediately following sibling of each DOM element within a set of DOM elements.

                                                                                          Example 1

                                                                                          cy.get('nav a:first').next()

                                                                                          See Also

                                                                                          • https://on.cypress.io/next

                                                                                        • Get the immediately following sibling of each DOM element within a set of DOM elements that match selector

                                                                                          Example 1

                                                                                          cy.get('nav a:first').next('.menu-item)

                                                                                          See Also

                                                                                          • https://on.cypress.io/next

                                                                                        method nextAll

                                                                                        nextAll: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends HTMLElement = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends HTMLElement = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get all following siblings of each DOM element in a set of matched DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/nextall

                                                                                        method nextUntil

                                                                                        nextUntil: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        element: E | JQuery<E>,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get all following siblings of each DOM element in a set of matched DOM elements up to, but not including, the element provided.

                                                                                          See Also

                                                                                          • https://on.cypress.io/nextuntil

                                                                                        method not

                                                                                        not: (
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<JQuery>;
                                                                                        • Filter DOM element(s) from a set of DOM elements. Opposite of .filter()

                                                                                          See Also

                                                                                          • https://on.cypress.io/not

                                                                                        method now

                                                                                        now: (name: string, ...args: any[]) => Promise<any> | ((subject: any) => any);
                                                                                        • Invoke a command synchronously, without using the command queue.

                                                                                          See Also

                                                                                          • https://on.cypress.io/api/custom-queries

                                                                                        method origin

                                                                                        origin: {
                                                                                        <T extends unknown>(urlOrDomain: string, fn: () => void): Chainable<T>;
                                                                                        <T, S extends unknown>(
                                                                                        urlOrDomain: string,
                                                                                        options: { args: T },
                                                                                        fn: (args: T) => void
                                                                                        ): Chainable<S>;
                                                                                        };
                                                                                        • Enables running Cypress commands in a secondary origin.

                                                                                          Example 1

                                                                                          cy.origin('example.com', () => { cy.get('h1').should('equal', 'Example Domain') })

                                                                                          See Also

                                                                                          • https://on.cypress.io/origin

                                                                                        • Enables running Cypress commands in a secondary origin.

                                                                                          Example 1

                                                                                          cy.origin('example.com', { args: { key: 'value', foo: 'foo' } }, ({ key, foo }) => { expect(key).to.equal('value') expect(foo).to.equal('foo') })

                                                                                          See Also

                                                                                          • https://on.cypress.io/origin

                                                                                        method parent

                                                                                        parent: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the parent DOM element of a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/parent

                                                                                        method parents

                                                                                        parents: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the parent DOM elements of a set of DOM elements.

                                                                                          See Also

                                                                                          • https://on.cypress.io/parents

                                                                                        method parentsUntil

                                                                                        parentsUntil: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        element: E | JQuery<E>,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get all ancestors of each DOM element in a set of matched DOM elements up to, but not including, the element provided.

                                                                                          See Also

                                                                                          • https://on.cypress.io/parentsuntil

                                                                                        method pause

                                                                                        pause: (options?: Partial<Loggable>) => Chainable<Subject>;
                                                                                        • Stop cy commands from running and allow interaction with the application under test. You can then "resume" running all commands or choose to step through the "next" commands from the Command Log. This does not set a debugger in your code, unlike .debug()

                                                                                          See Also

                                                                                          • https://on.cypress.io/pause

                                                                                        method prev

                                                                                        prev: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get the immediately preceding sibling of each element in a set of the elements.

                                                                                          Example 1

                                                                                          cy.get('nav').prev('a') // Yield previous 'a'

                                                                                          See Also

                                                                                          • https://on.cypress.io/prev

                                                                                        • Get the immediately preceding sibling of each element in a set of the elements.

                                                                                          Example 1

                                                                                          cy.get('li').prev() // Yield previous 'li'

                                                                                          See Also

                                                                                          • https://on.cypress.io/prev

                                                                                        • Get the immediately preceding sibling of each element in a set of the elements that match selector.

                                                                                          Example 1

                                                                                          cy.get('nav').prev('.menu-item') // Yield previous '.menu-item'

                                                                                          See Also

                                                                                          • https://on.cypress.io/prev

                                                                                        method prevAll

                                                                                        prevAll: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get all previous siblings of each DOM element in a set of matched DOM elements. > The querying behavior of this command matches exactly how [.prevAll()](http://api.jquery.com/prevAll) works in jQuery.

                                                                                          See Also

                                                                                          • https://on.cypress.io/prevall

                                                                                        method prevUntil

                                                                                        prevUntil: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        element: E | JQuery<E>,
                                                                                        filter?: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get all previous siblings of each DOM element in a set of matched DOM elements up to, but not including, the element provided. > The querying behavior of this command matches exactly how [.prevUntil()](http://api.jquery.com/prevUntil) works in jQuery.

                                                                                          See Also

                                                                                          • https://on.cypress.io/prevuntil

                                                                                        method readFile

                                                                                        readFile: {
                                                                                        <Contents = any>(
                                                                                        filePath: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<Contents>;
                                                                                        <Contents = any>(
                                                                                        filePath: string,
                                                                                        encoding: Encodings,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<Contents>;
                                                                                        };
                                                                                        • Read a file and yield its contents.

                                                                                          See Also

                                                                                          • https://on.cypress.io/readfile

                                                                                        • Read a file with given encoding and yield its contents.

                                                                                          Example 1

                                                                                          cy.readFile('foo.json', 'utf8')

                                                                                          See Also

                                                                                          • https://on.cypress.io/readfile

                                                                                        method reload

                                                                                        reload: {
                                                                                        (): Chainable<AUTWindow>;
                                                                                        (options: Partial<Loggable & Timeoutable>): Chainable<AUTWindow>;
                                                                                        (forceReload: boolean): Chainable<AUTWindow>;
                                                                                        (
                                                                                        forceReload: boolean,
                                                                                        options: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<AUTWindow>;
                                                                                        };
                                                                                        • Reload the page.

                                                                                          Example 1

                                                                                          cy.visit('http://localhost:3000/admin') cy.reload()

                                                                                          See Also

                                                                                          • https://on.cypress.io/reload

                                                                                        • Reload the page.

                                                                                          Parameter options

                                                                                          Pass in an options object to modify the default behavior of cy.reload()

                                                                                          Example 1

                                                                                          // Reload the page, do not log it in the command log and timeout after 15s cy.visit('http://localhost:3000/admin') cy.reload({log: false, timeout: 15000})

                                                                                          See Also

                                                                                          • https://on.cypress.io/reload

                                                                                        • Reload the page without cache

                                                                                          Parameter forceReload

                                                                                          Whether to reload the current page without using the cache. true forces the reload without cache.

                                                                                          Example 1

                                                                                          // Reload the page without using the cache cy.visit('http://localhost:3000/admin') cy.reload(true)

                                                                                          See Also

                                                                                          • https://on.cypress.io/reload

                                                                                        • Reload the page without cache and with log and timeout options

                                                                                          Parameter forceReload

                                                                                          Whether to reload the current page without using the cache. true forces the reload without cache.

                                                                                          Parameter options

                                                                                          Pass in an options object to modify the default behavior of cy.reload()

                                                                                          Example 1

                                                                                          // Reload the page without using the cache, do not log it in the command log and timeout after 15s cy.visit('http://localhost:3000/admin') cy.reload(true, {log: false, timeout: 15000})

                                                                                          See Also

                                                                                          • https://on.cypress.io/reload

                                                                                        method request

                                                                                        request: {
                                                                                        <T = any>(url: string, body?: RequestBody): Chainable<Response<T>>;
                                                                                        <T = any>(method: string, url: string, body?: RequestBody): Chainable<
                                                                                        Response<T>
                                                                                        >;
                                                                                        <T = any>(options: Partial<RequestOptions>): Chainable<Response<T>>;
                                                                                        };
                                                                                        • Make an HTTP GET request.

                                                                                          Example 1

                                                                                          cy.request('http://dev.local/seed')

                                                                                          See Also

                                                                                          • https://on.cypress.io/request

                                                                                        • Make an HTTP request with specific method.

                                                                                          Example 1

                                                                                          cy.request('POST', 'http://localhost:8888/users', {name: 'Jane'})

                                                                                          See Also

                                                                                          • https://on.cypress.io/request

                                                                                        • Make an HTTP request with specific behavior.

                                                                                          Example 1

                                                                                          cy.request({ url: '/dashboard', followRedirect: false // turn off following redirects })

                                                                                          See Also

                                                                                          • https://on.cypress.io/request

                                                                                        method rightclick

                                                                                        rightclick: {
                                                                                        (options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        (
                                                                                        position: PositionType,
                                                                                        options?: Partial<ClickOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        (x: number, y: number, options?: Partial<ClickOptions>): Chainable<Subject>;
                                                                                        };
                                                                                        • Right-click a DOM element.

                                                                                          See Also

                                                                                          • https://on.cypress.io/rightclick

                                                                                        • Right-click a DOM element at specific corner / side.

                                                                                          Parameter position

                                                                                          The position where the click should be issued. The center position is the default position.

                                                                                          Example 1

                                                                                          cy.get('button').rightclick('topRight')

                                                                                          See Also

                                                                                          • https://on.cypress.io/click

                                                                                        • Right-click a DOM element at specific coordinates

                                                                                          Parameter x

                                                                                          The distance in pixels from the element's left to issue the click.

                                                                                          Parameter y

                                                                                          The distance in pixels from the element's top to issue the click.

                                                                                          Example 1

                                                                                          ``` // The click below will be issued inside of the element // (15px from the left and 40px from the top). cy.get('button').rightclick(15, 40) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/rightclick

                                                                                        method root

                                                                                        root: <E extends Node = HTMLHtmlElement>(
                                                                                        options?: Partial<Loggable>
                                                                                        ) => Chainable<JQuery<E>>;
                                                                                        • Get the root DOM element. The root element yielded is <html> by default. However, when calling .root() from a .within() command, the root element will point to the element you are "within".

                                                                                          See Also

                                                                                          • https://on.cypress.io/root

                                                                                        method screenshot

                                                                                        screenshot: {
                                                                                        (
                                                                                        options?: Partial<Loggable & Timeoutable & ScreenshotOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        fileName: string,
                                                                                        options?: Partial<Loggable & Timeoutable & ScreenshotOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Take a screenshot of the application under test and the Cypress Command Log.

                                                                                          Example 1

                                                                                          cy.screenshot() cy.get(".post").screenshot()

                                                                                          See Also

                                                                                          • https://on.cypress.io/screenshot

                                                                                        • Take a screenshot of the application under test and the Cypress Command Log and save under given filename.

                                                                                          Example 1

                                                                                          cy.screenshot("post-element") cy.get(".post").screenshot("post-element")

                                                                                          See Also

                                                                                          • https://on.cypress.io/screenshot

                                                                                        method scrollIntoView

                                                                                        scrollIntoView: (options?: Partial<ScrollIntoViewOptions>) => Chainable<Subject>;
                                                                                        • Scroll an element into view.

                                                                                          See Also

                                                                                          • https://on.cypress.io/scrollintoview

                                                                                        method scrollTo

                                                                                        scrollTo: {
                                                                                        (
                                                                                        position: PositionType,
                                                                                        options?: Partial<ScrollToOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        x: string | number,
                                                                                        y: string | number,
                                                                                        options?: Partial<ScrollToOptions>
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Scroll to a specific position.

                                                                                          See Also

                                                                                          • https://on.cypress.io/scrollto

                                                                                        • Scroll to a specific X,Y position.

                                                                                          See Also

                                                                                          • https://on.cypress.io/scrollto

                                                                                        method select

                                                                                        select: (
                                                                                        valueOrTextOrIndex: string | number | Array<string | number>,
                                                                                        options?: Partial<SelectOptions>
                                                                                        ) => Chainable<Subject>;
                                                                                        • Select an <option> with specific text, value, or index within a <select>.

                                                                                          See Also

                                                                                          • https://on.cypress.io/select

                                                                                        method selectFile

                                                                                        selectFile: (
                                                                                        files: FileReference | FileReference[],
                                                                                        options?: Partial<SelectFileOptions>
                                                                                        ) => Chainable<Subject>;
                                                                                        • Select a file with the given element, or drag and drop a file over any DOM subject.

                                                                                          Parameter files

                                                                                          The file(s) to select or drag onto this element.

                                                                                          Example 1

                                                                                          cy.get('input[type=file]').selectFile(Cypress.Buffer.from('text')) cy.get('input[type=file]').selectFile({ fileName: 'users.json', contents: [{name: 'John Doe'}] })

                                                                                          See Also

                                                                                          • https://on.cypress.io/selectfile

                                                                                        method session

                                                                                        session: (
                                                                                        id: string | object,
                                                                                        setup: () => void,
                                                                                        options?: SessionOptions
                                                                                        ) => Chainable<null>;
                                                                                        • Save/Restore browser Cookies, LocalStorage, and SessionStorage data resulting from the supplied setup function.

                                                                                          See Also

                                                                                          • https://on.cypress.io/session

                                                                                        method setCookie

                                                                                        setCookie: (
                                                                                        name: string,
                                                                                        value: string,
                                                                                        options?: Partial<SetCookieOptions>
                                                                                        ) => Chainable<Cookie>;
                                                                                        • Set a browser cookie.

                                                                                          See Also

                                                                                          • https://on.cypress.io/setcookie

                                                                                        method shadow

                                                                                        shadow: () => Chainable<Subject>;
                                                                                        • Traverse into an element's shadow root.

                                                                                          Example 1

                                                                                          cy.get('my-component') .shadow() .find('.my-button') .click()

                                                                                          See Also

                                                                                          • https://on.cypress.io/shadow

                                                                                        method siblings

                                                                                        siblings: {
                                                                                        <K extends keyof HTMLElementTagNameMap>(
                                                                                        selector: K,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<HTMLElementTagNameMap[K]>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <E extends Node = HTMLElement>(
                                                                                        selector: string,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        };
                                                                                        • Get sibling DOM elements.

                                                                                          Example 1

                                                                                          cy.get('td').siblings('a') // Yield all link siblings of "td"

                                                                                          See Also

                                                                                          • https://on.cypress.io/siblings

                                                                                        • Get all sibling DOM elements.

                                                                                          Example 1

                                                                                          cy.get('td').siblings() // Yield all siblings of "td"

                                                                                          See Also

                                                                                          • https://on.cypress.io/siblings

                                                                                        • Get all sibling DOM elements that match given selector.

                                                                                          Example 1

                                                                                          // Yield all elements with class "foo" that are siblings of "td" cy.get('td').siblings('.foo')

                                                                                          See Also

                                                                                          • https://on.cypress.io/siblings

                                                                                        method spread

                                                                                        spread: {
                                                                                        <S extends string | number | boolean | object | any[]>(
                                                                                        fn: (...args: any[]) => S
                                                                                        ): Chainable<S>;
                                                                                        (fn: (...args: any[]) => void): Chainable<Subject>;
                                                                                        };
                                                                                        • Expand an array into multiple arguments.

                                                                                          Example 1

                                                                                          cy.getCookies().spread((cookie1, cookie2, cookie3) => { // each cookie is now an individual argument })

                                                                                          See Also

                                                                                          • https://on.cypress.io/spread

                                                                                        method spy

                                                                                        spy: {
                                                                                        (): Agent<sinon.SinonSpy>;
                                                                                        (func: (...args: any[]) => any): Agent<sinon.SinonSpy<any[], any>>;
                                                                                        <T>(obj: T, method: keyof T): Agent<sinon.SinonSpy<any[], any>>;
                                                                                        };
                                                                                        • Returns a new spy function. > Note: .spy() assumes you are already familiar with our guide: [Stubs, Spies, and Clocks](https://on.cypress.io/stubs-spies-and-clocks)

                                                                                          Example 1

                                                                                          const fn = cy.spy() // returns "dumb" spy function fn(42) expect(fn).to.have.been.calledOnce expect(fn).to.have.always.been.calledWithExactly(42)

                                                                                          See Also

                                                                                          • https://on.cypress.io/spy

                                                                                        • Wraps existing function and spies on it, while passing arguments and results.

                                                                                          Example 1

                                                                                          const add = (a, b) => a + b const spy = cy.spy(add) expect(spy(2, 3)).to.equal(5) expect(spy).to.have.been.calledWithExactly(2, 3)

                                                                                          See Also

                                                                                          • https://on.cypress.io/spy

                                                                                        • Spy on a method.

                                                                                          Example 1

                                                                                          // assume App.start calls util.addListeners cy.spy(util, 'addListeners') App.start() expect(util.addListeners).to.be.called

                                                                                          See Also

                                                                                          • https://on.cypress.io/spy

                                                                                        method stub

                                                                                        stub: {
                                                                                        (): Agent<sinon.SinonStub>;
                                                                                        (obj: any): Agent<sinon.SinonStub<any[], any>>;
                                                                                        <T>(obj: T, method: keyof T): Agent<sinon.SinonStub<any[], any>>;
                                                                                        <T>(obj: T, method: keyof T, func: (...args: any[]) => any): Agent<
                                                                                        sinon.SinonStub<any[], any>
                                                                                        >;
                                                                                        };
                                                                                        • Replace a function, record its usage and control its behavior. > Note: .stub() assumes you are already familiar with our guide: [Stubs, Spies, and Clocks](https://on.cypress.io/stubs-spies-and-clocks)

                                                                                          Example 1

                                                                                          const fn = cy.stub() // stub without any arguments acts like a spy fn(42) expect(fn).to.have.been.calledOnce expect(fn).to.have.always.been.calledWithExactly(42)

                                                                                          See Also

                                                                                          • https://on.cypress.io/stub

                                                                                        • Stubs all the object's methods.

                                                                                          Example 1

                                                                                          const o = { toString () { return 'foo' } } expect(o.toString()).to.equal('foo') cy.stub(o) // because stub does not call original function expect(o.toString()).to.equal(undefined) expect(o.toString).to.have.been.calledOnce

                                                                                          See Also

                                                                                          • https://on.cypress.io/stub

                                                                                        • Stubs single method of an object.

                                                                                          Example 1

                                                                                          const o = {} expect(o.toString()).to.equal('[object Object]') cy.stub(o, 'toString').callsFake(() => 'foo') expect(o.toString()).to.equal('foo') expect(o.toString).to.have.been.calledOnce

                                                                                          See Also

                                                                                          • https://on.cypress.io/stub

                                                                                        • Stubs a method on an object

                                                                                          Deprecated

                                                                                          Use cy.stub(object, name).callsFake(fn) instead

                                                                                        method submit

                                                                                        submit: (options?: Partial<Loggable & Timeoutable>) => Chainable<Subject>;
                                                                                        • Submit a form.

                                                                                          See Also

                                                                                          • https://on.cypress.io/submit

                                                                                        method task

                                                                                        task: <S = unknown>(
                                                                                        event: string,
                                                                                        arg?: any,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ) => Chainable<S>;
                                                                                        • Run a task in Node via the plugins file.

                                                                                          See Also

                                                                                          • https://on.cypress.io/api/task

                                                                                        method then

                                                                                        then: {
                                                                                        <S>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => Chainable<S>
                                                                                        ): Chainable<S>;
                                                                                        <S>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => Chainable<S>
                                                                                        ): Chainable<S>;
                                                                                        <S>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => PromiseLike<S>
                                                                                        ): Chainable<S>;
                                                                                        <S>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => PromiseLike<S>
                                                                                        ): Chainable<S>;
                                                                                        <S extends string | number | boolean>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<S>;
                                                                                        <S extends HTMLElement>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<JQuery<S>>;
                                                                                        <S extends ArrayLike<HTMLElement>>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<JQuery<S extends ArrayLike<infer T> ? T : never>>;
                                                                                        <S extends object | any[]>(
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<S>;
                                                                                        <S>(fn: (this: ObjectLike, currentSubject: Subject) => S): ThenReturn<
                                                                                        Subject,
                                                                                        S
                                                                                        >;
                                                                                        <S extends HTMLElement>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<JQuery<S>>;
                                                                                        <S extends ArrayLike<HTMLElement>>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<JQuery<S extends ArrayLike<infer T> ? T : never>>;
                                                                                        <S extends string | number | boolean | object | any[]>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): Chainable<S>;
                                                                                        <S>(
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => S
                                                                                        ): ThenReturn<Subject, S>;
                                                                                        (
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => void
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        options: Partial<Timeoutable>,
                                                                                        fn: (this: ObjectLike, currentSubject: Subject) => void
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Enables you to work with the subject yielded from the previous command.

                                                                                          See Also

                                                                                          • https://on.cypress.io/then

                                                                                        • Enables you to work with the subject yielded from the previous command / promise.

                                                                                          See Also

                                                                                          • https://on.cypress.io/then

                                                                                        • Enables you to work with the subject yielded from the previous command.

                                                                                          Example 1

                                                                                          cy.get('.nav').then(($nav) => {}) // Yields .nav as first arg cy.location().then((loc) => {}) // Yields location object as first arg

                                                                                          See Also

                                                                                          • https://on.cypress.io/then

                                                                                        method tick

                                                                                        tick: (milliseconds: number, options?: Partial<Loggable>) => Chainable<Clock>;
                                                                                        • Move time after overriding a native time function with [cy.clock()](https://on.cypress.io/clock). cy.clock() must be called before cy.tick()

                                                                                          Example 1

                                                                                          cy.clock() ... // advance time by 10 minutes cy.tick(600*1000) // you can restore the real clock cy.tick(1000).then(clock => { clock.restore() }) // or use this shortcut cy.tick(5000).invoke('restore')

                                                                                          See Also

                                                                                          • https://on.cypress.io/clock

                                                                                        method title

                                                                                        title: (options?: Partial<Loggable & Timeoutable>) => Chainable<string>;
                                                                                        • Get the document.title property of the page that is currently active.

                                                                                          See Also

                                                                                          • https://on.cypress.io/title

                                                                                        method trigger

                                                                                        trigger: {
                                                                                        <K extends keyof DocumentEventMap>(
                                                                                        eventName: K,
                                                                                        options?: Partial<TriggerOptions & ObjectLike & DocumentEventMap[K]>
                                                                                        ): Chainable<Subject>;
                                                                                        <K extends keyof DocumentEventMap>(
                                                                                        eventName: K,
                                                                                        position?: PositionType,
                                                                                        options?: Partial<TriggerOptions & ObjectLike & DocumentEventMap[K]>
                                                                                        ): Chainable<Subject>;
                                                                                        <K extends keyof DocumentEventMap>(
                                                                                        eventName: K,
                                                                                        x: number,
                                                                                        y: number,
                                                                                        options?: Partial<TriggerOptions & ObjectLike & DocumentEventMap[K]>
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        eventName: string,
                                                                                        position?: PositionType,
                                                                                        options?: Partial<TriggerOptions & ObjectLike>
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        eventName: string,
                                                                                        options?: Partial<TriggerOptions & ObjectLike>
                                                                                        ): Chainable<Subject>;
                                                                                        (
                                                                                        eventName: string,
                                                                                        x: number,
                                                                                        y: number,
                                                                                        options?: Partial<TriggerOptions & ObjectLike>
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Trigger an event on a DOM element.

                                                                                          See Also

                                                                                          • https://on.cypress.io/trigger

                                                                                        • Trigger an event on a DOM element. Custom events... If the following were .triggerCustom, .trigger strongly typed with event data

                                                                                          Example 1

                                                                                          cy.get('a').trigger('mousedown')

                                                                                          See Also

                                                                                          • https://on.cypress.io/trigger

                                                                                        method type

                                                                                        type: (text: string, options?: Partial<TypeOptions>) => Chainable<Subject>;
                                                                                        • Type into a DOM element.

                                                                                          Example 1

                                                                                          cy.get('input').type('Hello, World') // type "hello" + press Enter cy.get('input').type('hello{enter}')

                                                                                          See Also

                                                                                          • https://on.cypress.io/type

                                                                                        method uncheck

                                                                                        uncheck: {
                                                                                        (options?: Partial<CheckOptions>): Chainable<Subject>;
                                                                                        (value: string, options?: Partial<CheckOptions>): Chainable<Subject>;
                                                                                        (values: string[], options?: Partial<CheckOptions>): Chainable<Subject>;
                                                                                        };
                                                                                        • Uncheck checkbox(es).

                                                                                          Example 1

                                                                                          // Unchecks checkbox element cy.get('[type="checkbox"]').uncheck() // Uncheck element with the id 'saveUserName' cy.get('#saveUserName').uncheck() // Uncheck all checkboxes cy.get(':checkbox').uncheck() // Uncheck the checkbox with the value of 'ga' cy.get('input[type="checkbox"]').uncheck(['ga'])

                                                                                          See Also

                                                                                          • https://on.cypress.io/uncheck

                                                                                        • Uncheck specific checkbox.

                                                                                          Example 1

                                                                                          // Uncheck the checkbox with the value of 'ga' cy.get('input[type="checkbox"]').uncheck('ga')

                                                                                          See Also

                                                                                          • https://on.cypress.io/uncheck

                                                                                        • Uncheck specific checkboxes.

                                                                                          Example 1

                                                                                          // Uncheck the checkbox with the value of 'ga', 'ma' cy.get('input[type="checkbox"]').uncheck(['ga', 'ma'])

                                                                                          See Also

                                                                                          • https://on.cypress.io/uncheck

                                                                                        method url

                                                                                        url: (options?: Partial<UrlOptions>) => Chainable<string>;
                                                                                        • Get the current URL of the page that is currently active.

                                                                                          cy.location('href')

                                                                                          See Also

                                                                                          • https://on.cypress.io/url

                                                                                        method viewport

                                                                                        viewport: {
                                                                                        (
                                                                                        preset: ViewportPreset,
                                                                                        orientation?: ViewportOrientation,
                                                                                        options?: Partial<Loggable>
                                                                                        ): Chainable<null>;
                                                                                        (
                                                                                        width: number,
                                                                                        height: number,
                                                                                        options?: Partial<Loggable>
                                                                                        ): Chainable<null>;
                                                                                        };
                                                                                        • Control the size and orientation of the screen for your application.

                                                                                          Example 1

                                                                                          // Set viewport to 550px x 750px cy.viewport(550, 750) // Set viewport to 357px x 667px cy.viewport('iphone-6')

                                                                                          See Also

                                                                                          • https://on.cypress.io/viewport

                                                                                        • Set viewport to the given resolution.

                                                                                          Example 1

                                                                                          // Set viewport to 550px x 750px cy.viewport(550, 750)

                                                                                          See Also

                                                                                          • https://on.cypress.io/viewport

                                                                                        method visit

                                                                                        visit: {
                                                                                        (url: string, options?: Partial<VisitOptions>): Chainable<AUTWindow>;
                                                                                        (options: Partial<VisitOptions> & { url: string }): Chainable<AUTWindow>;
                                                                                        };
                                                                                        • Visit the given url

                                                                                          Parameter url

                                                                                          The URL to visit. If relative uses baseUrl

                                                                                          Parameter options

                                                                                          Pass in an options object to change the default behavior of cy.visit()

                                                                                          Example 1

                                                                                          cy.visit('http://localhost:3000') cy.visit('/somewhere') // opens ${baseUrl}/somewhere cy.visit({ url: 'http://google.com', method: 'POST' })

                                                                                          See Also

                                                                                          • https://on.cypress.io/visit

                                                                                        method wait

                                                                                        wait: {
                                                                                        (ms: number, options?: Partial<Loggable & Timeoutable>): Chainable<Subject>;
                                                                                        <TRequest = any, TResponse = any>(
                                                                                        alias: string,
                                                                                        options?: Partial<WaitOptions>
                                                                                        ): Chainable<Interception<TRequest, TResponse>>;
                                                                                        (aliases: string[], options?: Partial<WaitOptions>): Chainable<
                                                                                        Interception<any, any>[]
                                                                                        >;
                                                                                        };
                                                                                        • Wait for a number of milliseconds. You almost never need to wait for an arbitrary period of time. There are always better ways to express this in Cypress, see the documentation.

                                                                                          Parameter ms

                                                                                          Milliseconds to wait.

                                                                                          Example 1

                                                                                          cy.wait(1000) // wait for 1 second

                                                                                          See Also

                                                                                          • https://on.cypress.io/wait

                                                                                        method window

                                                                                        window: (options?: Partial<Loggable & Timeoutable>) => Chainable<AUTWindow>;
                                                                                        • Get the window object of the page that is currently active.

                                                                                          Example 1

                                                                                          ``` cy.visit('http://localhost:8080/app') cy.window().then(function(win){ // win is the remote window // of the page at: http://localhost:8080/app }) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/window

                                                                                        method within

                                                                                        within: {
                                                                                        (fn: (currentSubject: Subject) => void): Chainable<Subject>;
                                                                                        (
                                                                                        options: Partial<Loggable>,
                                                                                        fn: (currentSubject: Subject) => void
                                                                                        ): Chainable<Subject>;
                                                                                        };
                                                                                        • Scopes all subsequent cy commands to within this element. Useful when working within a particular group of elements such as a <form>.

                                                                                          Example 1

                                                                                          ``` cy.get('form').within(($form) => { // cy.get() will only search for elements within form, // not within the entire document cy.get('input[name="username"]').type('john') cy.get('input[name="password"]').type('password') cy.root().submit() }) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/within

                                                                                        • Scopes all subsequent cy commands to within this element. Useful when working within a particular group of elements such as a <form>.

                                                                                          See Also

                                                                                          • https://on.cypress.io/within

                                                                                        method wrap

                                                                                        wrap: {
                                                                                        <E extends Node = HTMLElement>(
                                                                                        element: E | JQuery<E>,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<JQuery<E>>;
                                                                                        <F extends Promise<S>, S>(
                                                                                        promise: F,
                                                                                        options?: Partial<Loggable & Timeoutable>
                                                                                        ): Chainable<S>;
                                                                                        <S>(object: S, options?: Partial<Loggable & Timeoutable>): Chainable<S>;
                                                                                        };
                                                                                        • Yield the element passed into .wrap().

                                                                                          Example 1

                                                                                          ``` // wraps DOM element cy.get('form').within(($form) => { // more commands cy.wrap($form).should('have.class', 'form-container') }) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/wrap

                                                                                        • Yield the element passed into .wrap() to the next command in the Cypress chain.

                                                                                          Example 1

                                                                                          ``` cy.wrap(new Promise((resolve, reject) => { setTimeout(resolve, 1000); }).then(result => {}) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/wrap

                                                                                        • Yields whatever is passed into .wrap() to the next command in the Cypress chain.

                                                                                          Example 1

                                                                                          ``` // Make assertions about object cy.wrap({ amount: 10 }) .should('have.property', 'amount') .and('eq', 10) ```

                                                                                          See Also

                                                                                          • https://on.cypress.io/wrap

                                                                                        method writeFile

                                                                                        writeFile: {
                                                                                        (
                                                                                        filePath: string,
                                                                                        contents: FileContents,
                                                                                        encoding: Encodings
                                                                                        ): Chainable<null>;
                                                                                        (
                                                                                        filePath: string,
                                                                                        contents: FileContents,
                                                                                        options?: Partial<WriteFileOptions & Timeoutable>
                                                                                        ): Chainable<null>;
                                                                                        (
                                                                                        filePath: string,
                                                                                        contents: FileContents,
                                                                                        encoding: Encodings,
                                                                                        options?: Partial<WriteFileOptions & Timeoutable>
                                                                                        ): Chainable<null>;
                                                                                        };
                                                                                        • Write to a file with the specified contents.

                                                                                          See Also

                                                                                          • https://on.cypress.io/writefile ``` cy.writeFile('path/to/message.txt', 'Hello World') ```

                                                                                        • Write to a file with the specified encoding and contents.

                                                                                          See Also

                                                                                          • https://on.cypress.io/writefile ``` cy.writeFile('path/to/ascii.txt', 'Hello World', { flag: 'a+', encoding: 'ascii' }) ```

                                                                                        • Write to a file with the specified encoding and contents.

                                                                                          An encoding option in options will override the encoding argument.

                                                                                          See Also

                                                                                          • https://on.cypress.io/writefile ``` cy.writeFile('path/to/ascii.txt', 'Hello World', 'utf8', { flag: 'a+', }) ```

                                                                                        interface Chainer

                                                                                        interface Chainer<Subject> {}
                                                                                        • See Also

                                                                                          • https://on.cypress.io/should

                                                                                            Chainer Subject

                                                                                        call signature

                                                                                        (chainer: 'be.a', type: string): Chainable<Subject>;
                                                                                        • Asserts that the target's type is equal to the given string type. Types are case insensitive. See the type-detect project page for info on the type detection algorithm: https://github.com/chaijs/type-detect.

                                                                                          Example 1

                                                                                          cy.wrap('foo').should('be.a', 'string')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_a

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.above', value: number | Date): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a date greater than the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(6).should('be.above', 5)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_above

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.false'): Chainable<Subject>;
                                                                                        • Asserts that the target is strictly (===) equal to false.

                                                                                          Example 1

                                                                                          cy.wrap(false).should('be.false')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_false

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.equal', value: any): Chainable<Subject>;
                                                                                        • Asserts that the target is not strictly (===) equal to the given val.

                                                                                          Example 1

                                                                                          cy.wrap(1).should('not.equal', 2)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_equal

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.all.keys'
                                                                                        | 'not.have.keys'
                                                                                        | 'not.have.deep.keys'
                                                                                        | 'not.have.all.deep.keys',
                                                                                        ...value: string[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Causes all .keys assertions that follow in the chain to not require that the target have all of the given keys. This is the opposite of .any, which only requires that the target have at least one of the given keys.

                                                                                          Example 1

                                                                                          cy.wrap({ a: 1, b: 2 }).should('not.have.all.keys', 'c', 'd')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_all

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.any.keys' | 'not.include.any.keys',
                                                                                        ...value: string[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Causes all .keys assertions that follow in the chain to only require that the target not have at least one of the given keys. This is the opposite of .all, which requires that the target have all of the given keys.

                                                                                          Example 1

                                                                                          cy.wrap({ a: 1, b: 2 }).should('not.have.any.keys', 'c')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_any

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.deep.property',
                                                                                        value: string,
                                                                                        obj: object
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target does not have a property with the given key name. See the deep-eql project page for info on the deep equality algorithm: https://github.com/chaijs/deep-eql.

                                                                                          Example 1

                                                                                          cy.wrap({ x: {a: 1 }}).should('not.have.deep.property', 'y', { a: 1 })

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_property

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.length' | 'not.have.lengthOf',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not equal to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length', 2) cy.wrap('foo').should('not.have.length', 2) lengthOf

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.length.greaterThan' | 'not.have.lengthOf.greaterThan',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not greater than to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.greaterThan', 4) cy.wrap('foo').should('not.have.length.greaterThan', 4)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.length.gt'
                                                                                        | 'not.have.lengthOf.gt'
                                                                                        | 'not.have.length.above'
                                                                                        | 'not.have.lengthOf.above',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not greater than to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.gt', 4) cy.wrap('foo').should('not.have.length.gt', 4)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.length.gte'
                                                                                        | 'not.have.lengthOf.gte'
                                                                                        | 'not.have.length.at.least'
                                                                                        | 'not.have.lengthOf.at.least',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not greater than or equal to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.gte', 4) cy.wrap('foo').should('not.have.length.gte', 4)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.length.lessThan' | 'not.have.lengthOf.lessThan',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is less than to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('have.length.lessThan', 2) cy.wrap('foo').should('have.length.lessThan', 2)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.length.lt'
                                                                                        | 'not.have.lengthOf.lt'
                                                                                        | 'not.have.length.below'
                                                                                        | 'not.have.lengthOf.below',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not less than to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.lt', 2) cy.wrap('foo').should('not.have.length.lt', 2)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.greaterThan', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a date greater than the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(6).should('be.greaterThan', 5) above

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_above

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.length.lte'
                                                                                        | 'not.have.lengthOf.lte'
                                                                                        | 'not.have.length.at.most'
                                                                                        | 'not.have.lengthOf.at.most',
                                                                                        value: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is not less than or equal to the given number n.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.lte', 2) cy.wrap('foo').should('not.have.length.lte', 2)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.length.within' | 'not.have.lengthOf.within',
                                                                                        start: number,
                                                                                        finish: number
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target's length property is within start and finish.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.length.within', 6, 12)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_lengthof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.members' | 'not.have.deep.members',
                                                                                        values: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target array does not have the same members as the given array set.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.have.members', [4, 5, 6])

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_members

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.ordered.members', values: any[]): Chainable<Subject>;
                                                                                        • Asserts that the target array does not have the same members as the given array where order matters.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not. have.ordered.members', [4, 5, 6])

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_members

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.ownProperty', property: string): Chainable<Subject>;
                                                                                        • Causes all .property and .include assertions that follow in the chain to ignore inherited properties.

                                                                                          Example 1

                                                                                          Object.prototype.b = 2 cy.wrap({ a: 1 }).should('have.property', 'a').and('not.have.ownProperty', 'b')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_ownproperty

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.have.property'
                                                                                        | 'not.have.nested.property'
                                                                                        | 'not.have.own.property'
                                                                                        | 'not.have.a.property'
                                                                                        | 'not.have.deep.property'
                                                                                        | 'not.have.deep.own.property'
                                                                                        | 'not.have.deep.nested.property',
                                                                                        property: string,
                                                                                        value?: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target has a property with the given key name.

                                                                                          Example 1

                                                                                          cy.wrap({ a: 1 }).should('not.have.property', 'b') cy.wrap({ a: 1 }).should('not.have.property', 'b', 1)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_property

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.ownPropertyDescriptor' | 'not.haveOwnPropertyDescriptor',
                                                                                        name: string,
                                                                                        descriptor?: PropertyDescriptor
                                                                                        ): Chainable<Subject>;
                                                                                        • Asserts that the target has its own property descriptor with the given key name.

                                                                                          Example 1

                                                                                          cy.wrap({a: 1}).should('not.have.ownPropertyDescriptor', 'a', { value: 2 })

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_ownpropertydescriptor

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.string', match: string | RegExp): Chainable<Subject>;
                                                                                        • Asserts that the target string does not contains the given substring str.

                                                                                          Example 1

                                                                                          cy.wrap('foobar').should('not.have.string', 'baz')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_string

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.include'
                                                                                        | 'not.deep.include'
                                                                                        | 'not.nested.include'
                                                                                        | 'not.own.include'
                                                                                        | 'not.deep.own.include'
                                                                                        | 'not.deep.nested.include',
                                                                                        value: any
                                                                                        ): Chainable<Subject>;
                                                                                        • When the target is a string, .include asserts that the given string val is not a substring of the target.

                                                                                          Example 1

                                                                                          cy.wrap('foobar').should('not.include', 'baz')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_include

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.include.members'
                                                                                        | 'not.include.ordered.members'
                                                                                        | 'not.include.deep.ordered.members',
                                                                                        value: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • When the target is a string, .include asserts that the given string val is not a substring of the target.

                                                                                          Example 1

                                                                                          cy.wrap([1, 2, 3]).should('not.include.members', [4, 5])

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_members

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.gt', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a date greater than the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(6).should('be.gt', 5) above

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_above

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.increase', value: object, property?: string): Chainable<Subject>;
                                                                                        • When one argument is provided, .increase asserts that the given function subject returns a greater number when it's invoked after invoking the target function compared to when it's invoked beforehand. .increase also causes all .by assertions that follow in the chain to assert how much greater of a number is returned. It's often best to assert that the return value increased by the expected amount, rather than asserting it increased by any amount.

                                                                                          When two arguments are provided, .increase asserts that the value of the given object subject's prop property is greater after invoking the target function compared to beforehand.

                                                                                          Example 1

                                                                                          let val = 1 function addTwo() { val += 2 } function getVal() { return val } cy.wrap(() => {}).should('not.increase', getVal)

                                                                                          const myObj = { val: 1 } function addTwo() { myObj.val += 2 } cy.wrap(addTwo).should('increase', myObj, 'val')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_increase

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.match', value: RegExp): Chainable<Subject>;
                                                                                        • Asserts that the target does not match the given regular expression re.

                                                                                          Example 1

                                                                                          cy.wrap('foobar').should('not.match', /baz$/)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_match

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.respondTo', value: string): Chainable<Subject>;
                                                                                        • When the target is a non-function object, .respondTo asserts that the target does not have a method with the given name method. The method can be own or inherited, and it can be enumerable or non-enumerable.

                                                                                          Example 1

                                                                                          class Cat { meow() {} } cy.wrap(new Cat()).should('not.respondTo', 'bark')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_respondto

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.satisfy', fn: (val: any) => boolean): Chainable<Subject>;
                                                                                        • Invokes the given matcher function with the target being passed as the first argument, and asserts that the value returned is falsy.

                                                                                          Example 1

                                                                                          cy.wrap(1).should('not.satisfy', (num) => num < 0)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_satisfy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.throw', value?: string | RegExp): Chainable<Subject>;
                                                                                        • When no arguments are provided, .throw invokes the target function and asserts that no error is thrown. When one argument is provided, and it's a string, .throw invokes the target function and asserts that no error is thrown with a message that contains that string.

                                                                                          Example 1

                                                                                          function badFn() { console.log('Illegal salmon!') } cy.wrap(badFn).should('not.throw') cy.wrap(badFn).should('not.throw', 'salmon') cy.wrap(badFn).should('not.throw', /salmon/)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_throw

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.throw',
                                                                                        error: Error | Function,
                                                                                        expected?: string | RegExp
                                                                                        ): Chainable<Subject>;
                                                                                        • When no arguments are provided, .throw invokes the target function and asserts that no error is thrown. When one argument is provided, and it's a string, .throw invokes the target function and asserts that no error is thrown with a message that contains that string.

                                                                                          Example 1

                                                                                          function badFn() { console.log('Illegal salmon!') } cy.wrap(badFn).should('not.throw') cy.wrap(badFn).should('not.throw', 'salmon') cy.wrap(badFn).should('not.throw', /salmon/)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_throw

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.oneOf', list: ReadonlyArray<any>): Chainable<Subject>;
                                                                                        • Asserts that the target is a member of the given array list.

                                                                                          Example 1

                                                                                          cy.wrap(42).should('not.be.oneOf', [1, 2, 3])

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_oneof

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.extensible'): Chainable<Subject>;
                                                                                        • Asserts that the target is extensible, which means that new properties can be added to it.

                                                                                          Example 1

                                                                                          let o = Object.seal({}) cy.wrap(o).should('not.be.extensible')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_extensible

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.sealed'): Chainable<Subject>;
                                                                                        • Asserts that the target is sealed, which means that new properties can't be added to it, and its existing properties can't be reconfigured or deleted.

                                                                                          Example 1

                                                                                          cy.wrap({a: 1}).should('be.sealed') cy.wrap({a: 1}).should('be.sealed')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_sealed

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.frozen'): Chainable<Subject>;
                                                                                        • Asserts that the target is frozen, which means that new properties can't be added to it, and its existing properties can't be reassigned to different values, reconfigured, or deleted.

                                                                                          Example 1

                                                                                          cy.wrap({a: 1}).should('not.be.frozen')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_frozen

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.gte', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a n date greater than or equal to the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(6).should('be.gte', 5) least

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_least

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.finite'): Chainable<Subject>;
                                                                                        • Asserts that the target is a number, and isn't NaN or positive/negative Infinity.

                                                                                          Example 1

                                                                                          cy.wrap(NaN).should('not.be.finite') cy.wrap(Infinity).should('not.be.finite')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_finite

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.always.calledWithNew' | 'always.have.been.calledWithNew'
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy/stub was called the new operator. Beware that this is inferred based on the value of the this object and the spy function's prototype, so it may give false positives if you actively return the right kind of object.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithnew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.always.calledWithMatch' | 'always.have.been.calledWithMatch',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert if spy was always called with matching arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwithmatcharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'always.returned' | 'have.always.returned',
                                                                                        value: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy always returned the provided value.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwaysreturnedobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.called' | 'have.been.called'): Chainable<Subject>;
                                                                                        • true if the spy was called at least once

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledAfter' | 'have.been.calledAfter',
                                                                                        spy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called after anotherSpy

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledafteranotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledBefore' | 'have.been.calledBefore',
                                                                                        spy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called before anotherSpy

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledbeforeanotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledOn' | 'have.been.calledOn',
                                                                                        context: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at least once with obj as this. calledOn also accepts a matcher (see [matchers](http://sinonjs.org/releases/v4.1.3/spies/#matchers)).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledonobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.calledOnce' | 'have.been.calledOnce'): Chainable<Subject>;
                                                                                        • Assert spy was called exactly once

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledonce

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.calledThrice' | 'have.been.calledThrice'): Chainable<Subject>;
                                                                                        • Assert spy was called exactly three times

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledthrice

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.lessThan', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a n date less than or equal to the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(4).should('be.lessThan', 5) below

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_below

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.calledTwice' | 'have.been.calledTwice'): Chainable<Subject>;
                                                                                        • Assert spy was called exactly twice

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledtwice

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledWithExactly' | 'have.been.calledWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at least once with the provided arguments and no others.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithexactlyarg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledWithMatch' | 'have.been.calledWithMatch',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called with matching arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithmatcharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.calledWithNew' | 'have.been.calledWithNew'): Chainable<Subject>;
                                                                                        • Assert spy/stub was called the new operator. Beware that this is inferred based on the value of the this object and the spy function's prototype, so it may give false positives if you actively return the right kind of object.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithnew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'have.always.thrown',
                                                                                        value?: Error | typeof Error | string
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy always threw an exception.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwaysthrew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.callCount', value: number): Chainable<Subject>;
                                                                                        • Assert the number of calls.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycallcount

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'have.thrown',
                                                                                        value?: Error | typeof Error | string
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy threw an exception at least once.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spythrew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'returned' | 'have.returned', value: any): Chainable<Subject>;
                                                                                        • Assert spy returned the provided value at least once. (see [matchers](http://sinonjs.org/releases/v4.1.3/spies/#matchers))

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyreturnedobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledImmediatelyBefore' | 'have.been.calledImmediatelyBefore',
                                                                                        anotherSpy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called before anotherSpy, and no spy calls occurred between spy and anotherSpy.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledimmediatelybeforeanotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledImmediatelyAfter' | 'have.been.calledImmediatelyAfter',
                                                                                        anotherSpy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called after anotherSpy, and no spy calls occurred between anotherSpy and spy.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledimmediatelyafteranotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.lt', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a n date less than or equal to the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(4).should('be.lt', 5) below

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_below

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.always.calledOn' | 'always.have.been.calledOn',
                                                                                        obj: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert the spy was always called with obj as this

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledonobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledWith' | 'have.been.calledWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at least once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.always.calledWith' | 'always.have.been.calledWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was always called with the provided arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledOnceWith' | 'have.been.calledOnceWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at exactly once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.always.calledWithExactly' | 'have.been.calledWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was always called with the exact provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwithexactlyarg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'be.calledOnceWithExactly' | 'have.been.calledOnceWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at exactly once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.always.returned', obj: any): Chainable<Subject>;
                                                                                        • Assert spy always returned the provided value.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.always.calledWithNew' | 'not.always.have.been.calledWithNew'
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy/stub was not called the new operator. Beware that this is inferred based on the value of the this object and the spy function's prototype, so it may give false positives if you actively return the right kind of object.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithnew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.be.always.calledWithMatch'
                                                                                        | 'not.always.have.been.calledWithMatch',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert if spy was not always called with matching arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwithmatcharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.always.returned' | 'not.have.always.returned',
                                                                                        value: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy not always returned the provided value.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwaysreturnedobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.lte', value: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a date less than or equal to the given number or date n respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(4).should('be.lte', 5) most

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_most

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.called' | 'not.have.been.called'): Chainable<Subject>;
                                                                                        • true if the spy was not called at least once

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledAfter' | 'not.have.been.calledAfter',
                                                                                        spy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not.called after anotherSpy

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledafteranotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledBefore' | 'not.have.been.calledBefore',
                                                                                        spy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called before anotherSpy

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledbeforeanotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledOn' | 'not.have.been.calledOn',
                                                                                        context: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called at least once with obj as this. calledOn also accepts a matcher (see [matchers](http://sinonjs.org/releases/v4.1.3/spies/#matchers)).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledonobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.calledOnce' | 'not.have.been.calledOnce'): Chainable<Subject>;
                                                                                        • Assert spy was not called exactly once

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledonce

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledThrice' | 'not.have.been.calledThrice'
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called exactly three times

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledthrice

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledTwice' | 'not.have.been.calledTwice'
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called exactly twice

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledtwice

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledWithExactly' | 'not.have.been.calledWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called at least once with the provided arguments and no others.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithexactlyarg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledWithMatch' | 'not.have.been.calledWithMatch',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was not called with matching arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithmatcharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledWithNew' | 'not.have.been.calledWithNew'
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy/stub was not called the new operator. Beware that this is inferred based on the value of the this object and the spy function's prototype, so it may give false positives if you actively return the right kind of object.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwithnew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.ok'): Chainable<Subject>;
                                                                                        • Asserts that the target is loosely (==) equal to true. However, it's often best to assert that the target is strictly (===) or deeply equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(1).should('be.ok')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_ok

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.always.thrown',
                                                                                        value?: Error | typeof Error | string
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy did not always throw an exception.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwaysthrew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.callCount', value: number): Chainable<Subject>;
                                                                                        • Assert not the number of calls.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycallcount

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.have.thrown',
                                                                                        value?: Error | typeof Error | string
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy did not throw an exception at least once.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spythrew

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.returned' | 'not.have.returned', value: any): Chainable<Subject>;
                                                                                        • Assert spy did not return the provided value at least once. (see [matchers](http://sinonjs.org/releases/v4.1.3/spies/#matchers))

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyreturnedobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.be.calledImmediatelyBefore'
                                                                                        | 'not.have.been.calledImmediatelyBefore',
                                                                                        anotherSpy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called before anotherSpy, and no spy calls occurred between spy and anotherSpy.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledimmediatelybeforeanotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.be.calledImmediatelyAfter'
                                                                                        | 'not.have.been.calledImmediatelyAfter',
                                                                                        anotherSpy: sinon.SinonSpy
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called after anotherSpy, and no spy calls occurred between anotherSpy and spy.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledimmediatelyafteranotherspy

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.always.calledOn' | 'not.always.have.been.calledOn',
                                                                                        obj: any
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert the spy was always called with obj as this

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledonobj

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledWith' | 'not.have.been.calledWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at least once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.always.calledWith' | 'not.always.have.been.calledWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was always called with the provided arguments (and possibly others).

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer: 'not.be.calledOnceWith' | 'not.have.been.calledOnceWith',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at exactly once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spycalledwitharg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.true'): Chainable<Subject>;
                                                                                        • Asserts that the target is strictly (===) equal to true.

                                                                                          Example 1

                                                                                          cy.wrap(true).should('be.true')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_true

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.be.always.calledWithExactly'
                                                                                        | 'not.have.been.calledWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was always called with the exact provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#spyalwayscalledwithexactlyarg1-arg2-

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (
                                                                                        chainer:
                                                                                        | 'not.be.calledOnceWithExactly'
                                                                                        | 'not.have.been.calledOnceWithExactly',
                                                                                        ...args: any[]
                                                                                        ): Chainable<Subject>;
                                                                                        • Assert spy was called at exactly once with the provided arguments.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.always.returned', obj: any): Chainable<Subject>;
                                                                                        • Assert spy always returned the provided value.

                                                                                          See Also

                                                                                          • http://sinonjs.org/releases/v4.1.3/spies/#

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.checked'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is checked, using .is(':checked').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.checked')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#checked

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.disabled'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is disabled, using .is(':disabled').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.disabled')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#disabled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.empty'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is empty, using .is(':empty'). If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.empty')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#empty

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.enabled'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is enabled, using .is(':enabled').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.enabled')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#enabled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.hidden'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is hidden, using .is(':hidden').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.hidden')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#hidden

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.selected'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is selected, using .is(':selected').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.selected')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#selected

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.visible'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is visible, using .is(':visible').

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.visible')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#visible

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.undefined'): Chainable<Subject>;
                                                                                        • Asserts that the target is strictly (===) equal to undefined.

                                                                                          Example 1

                                                                                          cy.wrap(undefined).should('be.undefined')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_undefined

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'contain', value: string): Chainable<Subject>;
                                                                                        • Assert that the selection contains the given text, using :contains(). If the object asserted against is not a jQuery object, or if contain is not called as a function, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('contain', 'text')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#containtext

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.focus'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is focused.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.focus') cy.get('#result').should('be.focused')

                                                                                          See Also

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.focused'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is focused.

                                                                                          Example 1

                                                                                          cy.get('#result').should('be.focused') cy.get('#result').should('have.focus')

                                                                                          See Also

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'exist'): Chainable<Subject>;
                                                                                        • Assert that the selection is not empty. Note that this overrides the built-in chai assertion. If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('exist')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#exist

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.attr', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given attribute, using .attr(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.attr', 'role') cy.get('#result').should('have.attr', 'role', 'menu')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#attrname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.class', value: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given attribute, using .attr(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.class', 'success')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#classclassname

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.css', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given CSS property, using .css(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.css', 'display', 'none')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#cssname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.data', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given data value, using .data(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.data', 'foo', 'bar')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#dataname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.descendants', selector: string): Chainable<Subject>;
                                                                                        • Assert that the selection contains at least one element which has a descendant matching the given selector, using .has().

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.descendants', 'h1')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#descendantsselector

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection is equal to the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.an', value: string): Chainable<Subject>;
                                                                                        • Asserts that the target's type is equal to the given string type. Types are case insensitive. See the type-detect project page for info on the type detection algorithm: https://github.com/chaijs/type-detect.

                                                                                          Example 1

                                                                                          cy.wrap({ foo: 'bar' }).should('be.an', 'object') a

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_a

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.null'): Chainable<Subject>;
                                                                                        • Asserts that the target is strictly (===) equal to null.

                                                                                          Example 1

                                                                                          cy.wrap(null).should('be.null')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_null

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'contain.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection partially contains the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('contain.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'include.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection partially contains the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('include.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.id', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given id, using .attr('id').

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.id', 'result')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#idid

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.prop', value: string, match?: any): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given property, using .prop(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.prop', 'disabled') cy.get('#result').should('have.prop', 'disabled', false)

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#propname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.text', value: string): Chainable<Subject>;
                                                                                        • Assert that the text of the first element of the selection is equal to the given text, using .text().

                                                                                          Example 1

                                                                                          cy.get('#result').should('have.text', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'contain.text', value: string): Chainable<Subject>;
                                                                                        • Assert that the text of the first element of the selection partially contains the given text, using .text().

                                                                                          Example 1

                                                                                          cy.get('#result').should('contain.text', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'include.text', value: string): Chainable<Subject>;
                                                                                        • Assert that the text of the first element of the selection partially contains the given text, using .text().

                                                                                          Example 1

                                                                                          cy.get('#result').should('include.text', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'have.value', value: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection has the given value, using .val().

                                                                                          Example 1

                                                                                          cy.get('textarea').should('have.value', 'foo bar baz')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'contain.value', value: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection partially contains the given value, using .val().

                                                                                          Example 1

                                                                                          cy.get('textarea').should('contain.value', 'foo bar baz')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'include.value', value: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection partially contains the given value, using .val().

                                                                                          Example 1

                                                                                          cy.get('textarea').should('include.value', 'foo bar baz')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.NaN'): Chainable<Subject>;
                                                                                        • Asserts that the target is strictly (===) equal to NaN.

                                                                                          Example 1

                                                                                          cy.wrap(NaN).should('be.NaN')

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_null

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'match', value: string): Chainable<Subject>;
                                                                                        • Assert that the selection matches a given selector, using .is(). Note that this overrides the built-in chai assertion. If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('match', ':empty')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#matchselector

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.checked'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not checked, using .is(':checked').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.checked')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#checked

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.disabled'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not disabled, using .is(':disabled').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.disabled')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#disabled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.empty'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not empty, using .is(':empty'). If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.empty')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#empty

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.enabled'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not enabled, using .is(':enabled').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.enabled')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#enabled

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.hidden'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not hidden, using .is(':hidden').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.hidden')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#hidden

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.selected'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not selected, using .is(':selected').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.selected')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#selected

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.visible'): Chainable<Subject>;
                                                                                        • Assert that at least one element of the selection is not visible, using .is(':visible').

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.visible')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#visible

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.focus'): Chainable<Subject>;
                                                                                        • Assert that no element of the selection is focused.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.focus') cy.get('#result').should('not.be.focused')

                                                                                          See Also

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.be.focused'): Chainable<Subject>;
                                                                                        • Assert that no element of the selection is focused.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.be.focused') cy.get('#result').should('not.have.focus')

                                                                                          See Also

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.within', start: number, end: number): Chainable<Subject>;
                                                                                        • Asserts that the target is a number or a date greater than or equal to the given number or date start, and less than or equal to the given number or date finish respectively. However, it's often best to assert that the target is equal to its expected value.

                                                                                          Example 1

                                                                                          cy.wrap(6).should('be.within', 5, 10)

                                                                                          See Also

                                                                                          • http://chaijs.com/api/bdd/#method_within

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.contain', value: string): Chainable<Subject>;
                                                                                        • Assert that the selection does not contain the given text, using :contains(). If the object asserted against is not a jQuery object, or if contain is not called as a function, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.contain', 'text')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#containtext

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.exist'): Chainable<Subject>;
                                                                                        • Assert that the selection is empty. Note that this overrides the built-in chai assertion. If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.exist')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#exist

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.attr', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection does not have the given attribute, using .attr(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.attr', 'role') cy.get('#result').should('not.have.attr', 'role', 'menu')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#attrname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.class', value: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection does not have the given attribute, using .attr(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.class', 'success')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#classclassname

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.css', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection does not have the given CSS property, using .css(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.css', 'display', 'none')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#cssname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.data', value: string, match?: string): Chainable<Subject>;
                                                                                        • Assert that the first element of the selection does not have the given data value, using .data(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.data', 'foo', 'bar')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#dataname-value

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.descendants', selector: string): Chainable<Subject>;
                                                                                        • Assert that the selection does not contain at least one element which has a descendant matching the given selector, using .has().

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.descendants', 'h1')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#descendantsselector

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.have.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection is not equal to the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.have.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.contain.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection does not contain the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.contain.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'not.include.html', value: string): Chainable<Subject>;
                                                                                        • Assert that the html of the first element of the selection does not contain the given html, using .html().

                                                                                          Example 1

                                                                                          cy.get('#result').should('not.include.html', 'John Doe')

                                                                                          See Also

                                                                                          • http://chaijs.com/plugins/chai-jquery/#htmlhtml

                                                                                          • https://on.cypress.io/assertions

                                                                                        call signature

                                                                                        (chainer: 'be.within', start: Date, end: Date): Chainable<Subject>;

                                                                                          call signature

                                                                                          (chainer: 'not.have.id', value: string, match?: string): Chainable<Subject>;
                                                                                          • Assert that the first element of the selection does not have the given id, using .attr('id').

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.have.id', 'result')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#idid

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.have.prop', value: string, match?: any): Chainable<Subject>;
                                                                                          • Assert that the first element of the selection does not have the given property, using .prop(). Optionally, assert a particular value as well. The return value is available for chaining.

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.have.prop', 'disabled') cy.get('#result').should('not.have.prop', 'disabled', false)

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#propname-value

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.have.text', value: string): Chainable<Subject>;
                                                                                          • Assert that the text of the first element of the selection is not equal to the given text, using .text().

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.have.text', 'John Doe')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.contain.text', value: string): Chainable<Subject>;
                                                                                          • Assert that the text of the first element of the selection does not contain the given text, using .text().

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.contain.text', 'John Doe')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.include.text', value: string): Chainable<Subject>;
                                                                                          • Assert that the text of the first element of the selection does not contain the given text, using .text().

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.include.text', 'John Doe')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#texttext

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.have.value', value: string): Chainable<Subject>;
                                                                                          • Assert that the first element of the selection does not have the given value, using .val().

                                                                                            Example 1

                                                                                            cy.get('textarea').should('not.have.value', 'foo bar baz')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.contain.value', value: string): Chainable<Subject>;
                                                                                          • Assert that the first element of the selection does not contain the given value, using .val().

                                                                                            Example 1

                                                                                            cy.get('textarea').should('not.contain.value', 'foo bar baz')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.include.value', value: string): Chainable<Subject>;
                                                                                          • Assert that the first element of the selection does not contain the given value, using .val().

                                                                                            Example 1

                                                                                            cy.get('textarea').should('not.include.value', 'foo bar baz')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#valuevalue

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainer: 'not.match', value: string): Chainable<Subject>;
                                                                                          • Assert that the selection does not match a given selector, using .is(). Note that this overrides the built-in chai assertion. If the object asserted against is not a jQuery object, the original implementation will be called.

                                                                                            Example 1

                                                                                            cy.get('#result').should('not.match', ':empty')

                                                                                            See Also

                                                                                            • http://chaijs.com/plugins/chai-jquery/#matchselector

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainers: string, value?: any): Chainable<Subject>;
                                                                                          • Create an assertion. Assertions are automatically retried until they pass or time out. Ctrl+Space will invoke auto-complete in most editors.

                                                                                            See Also

                                                                                            • https://on.cypress.io/should

                                                                                          call signature

                                                                                          (chainer: 'change', fn: (...args: any[]) => any): Chainable<Subject>;
                                                                                          • When one argument is provided, .change asserts that the given function subject returns a different value when it's invoked before the target function compared to when it's invoked afterward. However, it's often best to assert that subject is equal to its expected value.

                                                                                            Example 1

                                                                                            let dots = '' function addDot() { dots += '.' } function getDots() { return dots } cy.wrap(addDot).should('change', getDots)

                                                                                            See Also

                                                                                            • http://chaijs.com/api/bdd/#method_change

                                                                                            • https://on.cypress.io/assertions

                                                                                          call signature

                                                                                          (chainers: string, value: any, match: any): Chainable<Subject>;

                                                                                            call signature

                                                                                            (fn: (currentSubject: Subject) => void): Chainable<Subject>;
                                                                                            • Create an assertion. Assertions are automatically retried until they pass or time out. Passing a function to .should() enables you to make multiple assertions on the yielded subject. This also gives you the opportunity to massage what you'd like to assert on. Just be sure _n