nightwatch

property '[attributes]'

'[attributes]': {};

property '[client]'

'[client]': NightwatchClient;

property '[instance]'

'[instance]': any;

property argv

readonly argv: { [key: string]: any };

• Get all current cli arguments.

property desiredCapabilities

desiredCapabilities: NightwatchDesiredCapabilities;

• Get or set testsuite specific capabilities.

property disabled

disabled: boolean;

• Set to true if you'd like this test suite to be skipped by the test runner.

property endSessionOnFail

endSessionOnFail: boolean;

• Set to false if you'd like the browser window to be kept open in case of a failure or error (useful for debugging).

property globals

readonly globals: NightwatchGlobals;

• Get all current globals.

property mochaOptions

readonly mochaOptions: { [key: string]: any };

• Get all current mocha options.

property name

readonly name: string;

• Title of the describe suite.

property page

readonly page: {
    [name: string]: () => EnhancedPageObject<any, any, any, {}, string>;
} & { [name: string]: NightwatchPage } & NightwatchCustomPageObjects;

• Get available page objects.

property settings

readonly settings: NightwatchOptions;

• Get all current settings.

property skipTestcasesOnFail

skipTestcasesOnFail: boolean;

• Set to false if you'd like the rest of the test cases/test steps to be executed in the event of an assertion failure/error.

property tags

tags: string | string[];

• Get or set tags for the test suite.

  See Also

  • https://nightwatchjs.org/guide/running-tests/filtering-by-test-tags.html

property unitTest

unitTest: boolean;

• Enable if the current test is a unit/integration test (no webdriver session is required).

method retries

retries: (n: number) => void;

• How many time to retry a failed testcase inside this test suite

method retryInterval

retryInterval: (value: number) => void;

• Control the polling interval between re-tries for assertions or element commands.

  Parameter value

  Time interval in ms

method suiteRetries

suiteRetries: (n: number) => void;

• How many times to retry the current test suite in case of an assertion failure or error

method timeout

timeout: (value: number) => void;

• Control the unit test timeout.

  Control the assertion and element commands timeout until when an element should be located or assertion passed.

  Parameter value

  Timeout in ms

method waitForRetryInterval

waitForRetryInterval: { (): number; (value: number): void };

• Get the polling interval between re-tries for assertions or element commands.

  Returns

  Time interval in ms

• Control the polling interval between re-tries for assertions or element commands.

  Parameter value

  Time interval in ms

method waitForTimeout

waitForTimeout: { (): number; (value: number): void };

• Get the assertion and element commands timeout until when an element would be located or assertion passed.

  Returns

  Timeout in ms

• Control the assertion and element commands timeout until when an element should be located or assertion passed.

  Parameter value

  Timeout in ms

property abortOnFailure

abortOnFailure?: boolean;

property index

index: number;

property locateStrategy

locateStrategy: LocateStrategy;

property message

message?: string;

property name

name: string;

property parent

parent: any;

property pseudoSelector

pseudoSelector: string;

property resolvedElement

resolvedElement: string;

property retryInterval

retryInterval?: number;

property selector

selector: string;

property suppressNotFoundErrors

suppressNotFoundErrors?: boolean;

property timeout

timeout?: number;

property usingRecursion

usingRecursion: boolean;

property webElement

webElement?: WebElement;

property webElementId

webElementId?: string;

constructor

constructor(element: ScopedElement, options: ElementAssertionsOptions);

property not

readonly not: ElementAssertions;

method enabled

enabled: (message?: string) => Promise<WebElement>;

method hasAttribute

hasAttribute: (name: string, message?: string) => Promise<WebElement>;

method hasClass

hasClass: (name: string, message?: string) => Promise<WebElement>;

method hasDescendants

hasDescendants: (message?: string) => Promise<WebElement>;

method present

present: (message?: string) => Promise<WebElement>;

method selected

selected: (message?: string) => Promise<WebElement>;

method visible

visible: (message?: string) => Promise<WebElement>;

constructor

constructor(selector: any, nightwatchInstance: NightwatchClient);

property abortOnFailure

abortOnFailure: boolean;

property condition

condition: any;

property index

index: number;

property locateStrategy

locateStrategy: LocateStrategy;

property retryInterval

retryInterval: number;

property suppressNotFoundErrors

suppressNotFoundErrors: boolean;

property timeout

timeout: number;

constructor

constructor(
    selector: any,
    parentScopedElement: ScopedElement,
    nightwatchInstance: NightwatchClient
);

method count

count: () => ElementValue<number>;

method nth

nth: (index: number) => ScopedElement;

method then

then: <R1 = WebElement[], R2 = never>(
    onfulfilled?: (value: WebElement[]) => R1 | PromiseLike<R1>,
    onrejected?: (reason: any) => R2 | PromiseLike<R2>
) => PromiseLike<R1 | R2>;

constructor

constructor(elements: Elements, options: ElementsAssertionsOptions);

property not

readonly not: ElementsAssertions;

constructor

constructor(value: T | PromiseLike<T>, nightwatchInstance: NightwatchClient);

property assert

readonly assert: ValueAssertions<T>;

property value

value: Promise<T>;

method map

map: <K>(callback: (value: T) => K | PromiseLike<K>) => ElementValue<K>;

method then

then: <R1 = T, R2 = never>(
    onfulfilled?: (value: T) => R1 | PromiseLike<R1>,
    onrejected?: (reason: any) => R2 | PromiseLike<R2>
) => PromiseLike<R1 | R2>;

constructor

constructor(scopedValue: ElementValue<T>, options: ValueAssertionsOptions);

property not

readonly not: ValueAssertions<T>;

property scopedValue

scopedValue: ElementValue<T>;

method contains

contains: (expected: string, message?: string) => Promise<T>;

method equals

equals: (expected: T, message?: string) => Promise<T>;

method matches

matches: (expected: string | RegExp, message?: string) => Promise<T>;

method accept

accept: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Accepts the currently displayed alert dialog. Usually, this is equivalent to clicking on the 'OK' button in the dialog.

  Example 1

  module.exports = { 'accept open alert': function (browser) { browser .alerts.accept(function () { console.log('alert accepted successfully'); }); },

  'accept open alert with ES6 async/await': async function (browser) { await browser.alerts.accept(); } };

method dismiss

dismiss: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Dismisses the currently displayed alert dialog.

  For confirm() and prompt() dialogs, this is equivalent to clicking the 'Cancel' button. For alert() dialogs, this is equivalent to clicking the 'OK' button.

  Example 1

  module.exports = { 'dismiss open alert': function (browser) { browser .alerts.dismiss(function () { console.log('alert dismissed successfully'); }); },

  'dismiss open alert with ES6 async/await': async function (browser) { await browser.alerts.dismiss(); } };

method getText

getText: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, string>;

• Get the text of the currently displayed JavaScript alert(), confirm(), or prompt() dialog.

  Example 1

  module.exports = { 'get open alert text': function (browser) { browser .alerts.getText(function (result) { console.log('text on open alert:', result.value); }); },

  'get open alert text with ES6 async/await': async function (browser) { const alertText = await browser.alerts.getText(); console.log('text on open alert:', alertText); } };

method setText

setText: (
    value: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Send keystrokes to a JavaScript prompt() dialog.

  Example 1

  module.exports = { 'set text on JS prompt': function (browser) { browser .alerts.setText('some text', function () { console.log('text sent to JS prompt successfully'); }); },

  'set text on JS prompt with ES6 async/await': async function (browser) { await browser.alerts.setText('some text'); } };

method getContext

getContext: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string | null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, string | null>;

• Get the current context in which Appium is running. Used when testing hybrid mobile apps using Appium.

  More info here: https://appium.io/docs/en/commands/context/get-context/

  Example 1

  module.exports = { 'get current context': function (app) { app .appium.getContext(function (result) { console.log('the current context is:', result.value); }); },

  'get current context with ES6 async/await': async function (app) { const context = await app.appium.getContext(); console.log('the current context is:', context); } };

method getContexts

getContexts: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string[]>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, string[]>;

• Get a list of the available contexts. Used when testing hybrid mobile apps using Appium.

  More info here: https://appium.io/docs/en/commands/context/get-contexts/

  Example 1

  module.exports = { 'get available contexts': function (app) { app .appium.getContexts(function (result) { console.log('the available contexts are:', result.value); }); },

  'get available contexts with ES6 async/await': async function (app) { const contexts = await app.appium.getContexts(); console.log('the available contexts are:', contexts); } };

method getCurrentActivity

getCurrentActivity: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, string>;

• Get the name of the current Android activity.

  Example 1

  module.exports = { 'get current activity name': function (app) { app .appium.getCurrentActivity(function (result) { console.log('current android activity is:', result.value); }); },

  'get current activity name with ES6 async/await': async function (app) { const activity = await app.appium.getCurrentActivity(); console.log('current android activity is:', activity); } };

method getCurrentPackage

getCurrentPackage: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, string>;

• Get the name of the current Android package.

  Example 1

  module.exports = { 'get current package name': function (app) { app .appium.getCurrentPackage(function (result) { console.log('current android package is:', result.value); }); },

  'get current package name with ES6 async/await': async function (app) { const packageName = await app.appium.getCurrentPackage(); console.log('current android package is:', packageName); } };

method getGeolocation

getGeolocation: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<AppiumGeolocation>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, AppiumGeolocation>;

• Get the current geolocation of the mobile device.

  Example 1

  module.exports = { 'get device geolocation': function (app) { app .appium.getGeolocation(function (result) { console.log('current device geolocation is:', result.value); }); },

  'get device geolocation with ES6 async/await': async function (app) { const location = await app.appium.getGeolocation(); console.log('current device geolocation is:', location); } };

method getOrientation

getOrientation: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<'LANDSCAPE' | 'PORTRAIT'>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, 'LANDSCAPE' | 'PORTRAIT'>;

• Get the current device orientation.

  Example 1

  module.exports = { 'get current device orientation': function (app) { app .appium.getOrientation(function (result) { console.log('current device orientation is:', result.value); }); },

  'get current device orientation with ES6 async/await': async function (app) { const orientation = await app.appium.getOrientation(); console.log('current device orientation is:', orientation); } };

method hideKeyboard

hideKeyboard: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<boolean>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, boolean>;

• Hide soft keyboard.

  Example 1

  module.exports = { 'hide device soft keyboard': function (app) { app .appium.hideKeyboard(); },

  'hide device soft keyboard with ES6 async/await': async function (app) { await app.appium.hideKeyboard(); } };

method isKeyboardShown

isKeyboardShown: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<boolean>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, boolean>;

• Whether or not the soft keyboard is shown.

  Example 1

  module.exports = { 'whether keyboard is shown': function (app) { app .appium.isKeyboardShown(function (result) { console.log('result value of whether keyboard is shown:', result.value); }); },

  'whether keyboard is shown with ES6 async/await': async function (app) { const result = await app.appium.isKeyboardShown(); console.log('result value of whether keyboard is shown:', result); } };

method longPressKeyCode

longPressKeyCode: {
    (
        keycode: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<IfUnknown<ReturnType, this>, null>;
    (
        keycode: number,
        metastate?: number,
        flags?: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<IfUnknown<ReturnType, this>, null>;
};

• Press and hold a particular key on an Android Device.

  See [official Android Developers docs](https://developer.android.com/reference/android/view/KeyEvent.html) for reference of available Android key code values.

  Example 1

  module.exports = { 'long press e with caps lock on (keycode 33 and metastate 1048576)': function (app) { app .appium.longPressKeyCode(33, 1048576); },

  'long press g (keycode 35) with ES6 async/await': async function (app) { await app.appium.longPressKeyCode(35); } };

method pressKeyCode

pressKeyCode: {
    (
        keycode: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<IfUnknown<ReturnType, this>, null>;
    (
        keycode: number,
        metastate?: number,
        flags?: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<IfUnknown<ReturnType, this>, null>;
};

• Press a particular key on an Android Device.

  See [official Android Developers docs](https://developer.android.com/reference/android/view/KeyEvent.html) for reference of available Android key code values.

  Example 1

  module.exports = { 'press e with caps lock on (keycode 33 and metastate 1048576)': function (app) { app .appium.pressKeyCode(33, 1048576); },

  'press g (keycode 35) with ES6 async/await': async function (app) { await app.appium.pressKeyCode(35); } };

method resetApp

resetApp: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Reset the current session (run delete and create session).

  More info here: https://appium.io/docs/en/2.3/commands/base-driver/#reset

  Example 1

  module.exports = { 'start an android activity': function (app) { app .appium.resetApp(); },

  'reset the app activity and wait for onboarding activity to start': function (app) { app .appium.resetApp(); } };

method setContext

setContext: (
    context: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Set the context to be automated. Used when testing hybrid mobile apps using Appium.

  More info here: https://appium.io/docs/en/commands/context/set-context/

  Example 1

  module.exports = { 'switch to webview context': async function (app) { app .waitUntil(async function() { // wait for webview context to be available // initially, this.getContexts() only returns ['NATIVE_APP'] const contexts = await this.appium.getContexts();

  return contexts.length > 1; }) .perform(async function() { // switch to webview context const contexts = await this.appium.getContexts(); // contexts: ['NATIVE_APP', 'WEBVIEW_'] await this.appium.setContext(contexts[1]); }); },

  'switch to native context': function (app) { app.appium.setContext('NATIVE_APP'); } };

method setGeolocation

setGeolocation: (
    coordinates: AppiumGeolocation,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<AppiumGeolocation>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, AppiumGeolocation>;

• Set the current geolocation of the mobile device.

  Example 1

  module.exports = { 'set geolocation to Tokyo, Japan': function (app) { app .appium.setGeolocation({latitude: 35.689487, longitude: 139.691706, altitude: 5}); },

  'set geolocation to Tokyo, Japan with ES6 async/await': async function (app) { await app.appium.setGeolocation({latitude: 35.689487, longitude: 139.691706}); } };

method setOrientation

setOrientation: (
    orientation: 'LANDSCAPE' | 'PORTRAIT',
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<'LANDSCAPE' | 'PORTRAIT'>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, 'LANDSCAPE' | 'PORTRAIT'>;

• Set the current device orientation.

  Example 1

  module.exports = { 'set orientation to LANDSCAPE': function (app) { app .appium.setOrientation('LANDSCAPE'); } };

method startActivity

startActivity: (
    opts: {
        appPackage: string;
        appActivity: string;
        appWaitPackage?: string;
        appWaitActivity?: string;
        intentAction?: string;
        intentCategory?: string;
        intentFlags?: string;
        optionalIntentArguments?: string;
        dontStopAppOnReset?: boolean;
    },
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Start an Android activity by providing package name, activity name and other optional parameters.

  More info here: https://appium.io/docs/en/commands/device/activity/start-activity/

  Example 1

  module.exports = { 'start an android activity': function (app) { app .appium.startActivity({ appPackage: 'com.android.chrome', appActivity: 'com.google.android.apps.chrome.Main' }); },

  'start the main Android activity and wait for onboarding activity to start': function (app) { app .appium.startActivity({ appPackage: 'org.wikipedia', appActivity: 'org.wikipedia.main.MainActivity', appWaitActivity: 'org.wikipedia.onboarding.InitialOnboardingActivity' }); } };

property altitude

altitude?: number;

property latitude

latitude: number;

property longitude

longitude: number;

method deleteNetworkConditions

deleteNetworkConditions: () => Awaitable<IfUnknown<ReturnType, this>, null>;

• Delete Chromium network emulation settings.

method getCastIssueMessage

getCastIssueMessage: () => Awaitable<IfUnknown<ReturnType, this>, string>;

• Returns an error message when there is any issue in a Cast session.

method getCastSinks

getCastSinks: () => Awaitable<IfUnknown<ReturnType, this>, string[]>;

• Returns the list of cast sinks (Cast devices) available to the Chrome media router.

  An array of Strings containing the friendly device names of available cast sink targets.

method getNetworkConditions

getNetworkConditions: () => Awaitable<
    IfUnknown<ReturnType, this>,
    NetworkConditionsSpec
>;

• Get Chromium network emulation settings.

  Network conditions must be set before it can be retrieved.

method launchApp

launchApp: (id: string) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Launch Chrome App with given ID.

  Parameter id

  ID of the App to launch.

method sendAndGetDevToolsCommand

sendAndGetDevToolsCommand: (
    cmd: string,
    params?: { [key: string]: any }
) => Awaitable<IfUnknown<ReturnType, this>, unknown>;

• Sends an arbitrary devtools command to the browser and get the result.

  Parameter cmd

  The name of the command to send.

  Parameter params

  The command parameters.

  See Also

  • <https://chromedevtools.github.io/devtools-protocol/>

method sendDevToolsCommand

sendDevToolsCommand: (
    cmd: string,
    params?: { [key: string]: any }
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Sends an arbitrary devtools command to the browser.

  Parameter cmd

  The name of the command to send.

  Parameter params

  The command parameters.

  See Also

  • <https://chromedevtools.github.io/devtools-protocol/>

method setCastSinkToUse

setCastSinkToUse: (
    deviceName: string
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Selects a cast sink (Cast device) as the recipient of media router intents (connect or play).

  Parameter deviceName

  name of the target device.

method setDownloadPath

setDownloadPath: (path: string) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Sends a DevTools command to change the browser's download directory.

  Parameter path

  The desired download directory.

  See Also

  • chrome.sendDevToolsCommand

method setNetworkConditions

setNetworkConditions: (
    spec: NetworkConditionsSpec
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Set Chromium network emulation settings.

  Parameter spec

  Defines the network conditions to set

  Example 1

  describe('set network conditions', function() { it('sets the network conditions', function() { browser .chrome.setNetworkConditions({ offline: false, latency: 5, // Additional latency (ms). download_throughput: 500 * 1024, // Maximal aggregated download throughput. upload_throughput: 500 * 1024 // Maximal aggregated upload throughput. }); }); });

method setPermission

setPermission: (
    name: string,
    state: 'granted' | 'denied' | 'prompt'
) => Awaitable<IfUnknown<ReturnType, this>, null>;

• Set a permission state to the given value.

  Parameter name

  A name of the permission to update.

  Parameter state

  State to set permission to.

  See Also

  • <https://w3c.github.io/permissions/#permission-registry> for valid names

method startCastTabMirroring

startCastTabMirroring: (
    deviceName: string
) => Awaitable<IfUnknown<ReturnType, this>, null>;