@types/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]: () => any } & {
    [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;

method getContext

getContext: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string | null>
    ) => void
) => Awaitable<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, '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<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, null>;
    (
        keycode: number,
        metastate?: number,
        flags?: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<NightwatchAPI, 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<NightwatchAPI, null>;
    (
        keycode: number,
        metastate?: number,
        flags?: number,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): Awaitable<NightwatchAPI, 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 setContext

setContext: (
    context: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<NightwatchAPI, 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<NightwatchAPI, 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<NightwatchAPI, '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<NightwatchAPI, 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;

property args

args?: string[] | undefined;

• List of command-line arguments to use when starting Chrome. Arguments with an associated value should be separated by a '=' sign (e.g., ['start-maximized', 'user-data-dir=/tmp/temp_profile']).

property binary

binary?: string | undefined;

• Path to the Chrome executable to use (on Mac OS X, this should be the actual binary, not just the app. e.g., '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome')

property debuggerAddress

debuggerAddress?: string | undefined;

• An address of a Chrome debugger server to connect to, in the form of <hostname/ip:port>, e.g. '127.0.0.1:38947'

property detach

detach?: boolean | undefined;

• Default: false. If false, Chrome will be quit when ChromeDriver is killed, regardless of whether the session is quit. If true, Chrome will only be quit if the session is quit (or closed). Note, if true, and the session is not quit, ChromeDriver cannot clean up the temporary user data directory that the running Chrome instance is using.

property excludeSwitches

excludeSwitches?: string[] | undefined;

• List of Chrome command line switches to exclude that ChromeDriver by default passes when starting Chrome. Do not prefix switches with --.

property extensions

extensions?: string[] | undefined;

• A list of Chrome extensions to install on startup. Each item in the list should be a base-64 encoded packed Chrome extension (.crx)

property localState

localState?: Record<string, string> | undefined;

• A dictionary with each entry consisting of the name of the preference and its value. These preferences are applied to the Local State file in the user data folder.

property minidumpPath

minidumpPath?: string | undefined;

• Directory to store Chrome minidumps . (Supported only on Linux.)

property mobileEmulation

mobileEmulation?: Record<string, string> | undefined;

• A dictionary with either a value for “deviceName,” or values for “deviceMetrics” and “userAgent.” Refer to Mobile Emulation for more information.

property perfLoggingPrefs

perfLoggingPrefs?: ChromePerfLoggingPrefs | undefined;

• An optional dictionary that specifies performance logging preferences. See below for more information.

property prefs

prefs?: Record<string, string> | undefined;

• A dictionary with each entry consisting of the name of the preference and its value. These preferences are only applied to the user profile in use.

property windowTypes

windowTypes?: string[] | undefined;

• A list of window types that will appear in the list of window handles. For access to elements, include "webview" in this list.

property bufferUsageReportingInterval

bufferUsageReportingInterval?: number | undefined;

• Default: 1000. The requested number of milliseconds between DevTools trace buffer usage events. For example, if 1000, then once per second, DevTools will report how full the trace buffer is. If a report indicates the buffer usage is 100%, a warning will be issued.

property enableNetwork

enableNetwork?: boolean | undefined;

• Default: true. Whether or not to collect events from Network domain.

property enablePage

enablePage?: boolean | undefined;

• Default: true. Whether or not to collect events from Page domain.

property traceCategories

traceCategories?: string | undefined;

• A comma-separated string of Chrome tracing categories for which trace events should be collected. An unspecified or empty string disables tracing.

method captureBrowserConsoleLogs

captureBrowserConsoleLogs: (
    onEventCallback: (
        event: Pick<
            Protocol.Runtime.ConsoleAPICalledEvent,
            'type' | 'timestamp' | 'args'
        >
    ) => void,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Listen to the console events (ex. console.log event) and register callback to process the same.

  Example 1

  describe('capture console events', function() { it('captures and logs console.log event', function() { browser .captureBrowserConsoleLogs((event) => { console.log(event.type, event.timestamp, event.args[0].value); }) .navigateTo('https://www.google.com') .executeScript(function() { console.log('here'); }, []); }); });

  See Also

  • https://nightwatchjs.org/guide/running-tests/capture-console-messages.html

method captureBrowserExceptions

captureBrowserExceptions: (
    onExceptionCallback: (event: Protocol.Runtime.ExceptionThrownEvent) => void,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Catch the JavaScript exceptions thrown in the browser.

  Example 1

  describe('catch browser exceptions', function() { it('captures the js exceptions thrown in the browser', async function() { await browser.captureBrowserExceptions((event) => { console.log('>>> Exception:', event); });

  await browser.navigateTo('https://duckduckgo.com/');

  const searchBoxElement = await browser.findElement('input[name=q]'); await browser.executeScript(function(_searchBoxElement) { _searchBoxElement.setAttribute('onclick', 'throw new Error("Hello world!")'); }, [searchBoxElement]);

  await browser.elementIdClick(searchBoxElement.getId()); }); });

  See Also

  • https://nightwatchjs.org/guide/running-tests/catch-js-exceptions.html

method captureNetworkRequests

captureNetworkRequests: (
    onRequestCallback: (
        requestParams: Protocol.Network.RequestWillBeSentEvent
    ) => void,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Capture outgoing network calls from the browser.

  Example 1

  describe('capture network requests', function() { it('captures and logs network requests as they occur', function(this: ExtendDescribeThis<{requestCount: number}>) { this.requestCount = 1; browser .captureNetworkRequests((requestParams) => { console.log('Request Number:', this.requestCount!++); console.log('Request URL:', requestParams.request.url); console.log('Request method:', requestParams.request.method); console.log('Request headers:', requestParams.request.headers); }) .navigateTo('https://www.google.com'); }); });

  See Also

  • https://nightwatchjs.org/guide/network-requests/capture-network-calls.html

method enablePerformanceMetrics

enablePerformanceMetrics: (
    enable?: boolean,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Enable/disable the collection of performance metrics in the browser. Metrics collection only begin after this command is called.

  Example 1

  describe('collect performance metrics', function() { it('enables the metrics collection, does some stuff and collects the metrics', function() { browser .enablePerformanceMetrics() .navigateTo('https://www.google.com') .getPerformanceMetrics((result) => { if (result.status === 0) { const metrics = result.value; console.log(metrics); } }); }); });

  See Also

  • https://web.dev/metrics/

  • https://pptr.dev/api/puppeteer.page.metrics/

method getPerformanceMetrics

getPerformanceMetrics: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<{ [metricName: string]: number }>
    ) => void
) => Awaitable<this, { [metricName: string]: number }>;

• Get the performance metrics from the browser. Metrics collection only begin after enablePerformanceMetrics() command is called.

  Returns

  A promise that contains metrics collected between the last call to enablePerformanceMetrics() command and this command.

  Example 1

  describe('collect performance metrics', function() { it('enables the metrics collection, does some stuff and collects the metrics', function() { browser .enablePerformanceMetrics() .navigateTo('https://www.google.com') .getPerformanceMetrics((result) => { if (result.status === 0) { const metrics = result.value; console.log(metrics); } }); }); });

  See Also

  • https://web.dev/metrics/

  • https://pptr.dev/api/puppeteer.page.metrics/

method mockNetworkResponse

mockNetworkResponse: (
    urlToIntercept: string,
    response?: {
        status?: Protocol.Fetch.FulfillRequestRequest;
        headers?: { [name: string]: string };
        body?: Protocol.Fetch.FulfillRequestRequest;
    },
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Intercept the request made on a particular URL and mock the response.

  Example 1

  describe('mock network response', function() { it('intercepts the request made to Google search and mocks its response', function() { browser .mockNetworkResponse('https://www.google.com/', { status: 200, headers: { 'Content-Type': 'UTF-8' }, body: 'Hello there!' }) .navigateTo('https://www.google.com/') .pause(2000); }); });

  See Also

  • https://nightwatchjs.org/guide/network-requests/mock-network-response.html

method setDeviceDimensions

setDeviceDimensions: (
    metrics?: {
        width?: number;
        height?: number;
        deviceScaleFactor?: number;
        mobile?: boolean;
    },
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Override device mode/dimensions.

  Example 1

  describe('modify device dimensions', function() { it('modifies the device dimensions and then resets it', function() { browser .setDeviceDimensions({ width: 400, height: 600, deviceScaleFactor: 50, mobile: true }) .navigateTo('https://www.google.com') .pause(1000) .setDeviceDimensions() // resets the device dimensions .navigateTo('https://www.google.com') .pause(1000); }); });

  See Also

  • https://nightwatchjs.org/guide/mobile-web-testing/override-device-dimensions.html

method setGeolocation

setGeolocation: (
    coordinates?: { latitude: number; longitude: number; accuracy?: number },
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Mock the geolocation of the browser.

  Call without any arguments to reset the geolocation.

  Example 1

  describe('mock geolocation', function() { it('sets the geolocation to Tokyo, Japan and then resets it', () => { browser .setGeolocation({ latitude: 35.689487, longitude: 139.691706, accuracy: 100 }) // sets the geolocation to Tokyo, Japan .navigateTo('https://www.gps-coordinates.net/my-location') .pause(3000) .setGeolocation() // resets the geolocation .navigateTo('https://www.gps-coordinates.net/my-location') .pause(3000); }); });

  See Also

  • https://nightwatchjs.org/guide/network-requests/mock-geolocation.html

method takeHeapSnapshot

takeHeapSnapshot: (
    heapSnapshotLocation?: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<string>
    ) => void
) => Awaitable<this, string>;

• Take heap snapshot and save it as a .heapsnapshot file. The saved snapshot file can then be loaded into Chrome DevTools' Memory tab for inspection.

  The contents of the heap snapshot are also available in the value property of the result argument passed to the callback, in string-serialized JSON format.

  Returns

  A promise that contains heap snapshot in string-serialized JSON format.

  Example 1

  describe('take heap snapshot', function() { it('takes heap snapshot and saves it as snap.heapsnapshot file', function() { browser .navigateTo('https://www.google.com') .takeHeapSnapshot('./snap.heapsnapshot'); }); });

  See Also

  • https://nightwatchjs.org/guide/running-tests/take-heap-snapshot.html

method axeInject

axeInject: () => Awaitable<this, null>;

• Injects the axe-core js library into the current page (using the .executeScript() command) to be paired with axeRun to evaluate the axe-core accessibility rules.

  Example 1

  this.demoTest = function () { browser .url('https://nightwatchjs.org') .axeInject() .axeRun(); };

  See Also

  • https://nightwatchjs.org/api/axeInject.html

method axeRun

axeRun: (
    selector?: string,
    options?: { [key: string]: any },
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Analyzes the current page against applied axe rules.

  Parameter selector

  CSS selector to scope rule analysis against, will cascade to child elements

  Parameter options

  Allows configuration of what rules will be run (accessibility standard or rules to enable/disable)

  Example 1

  this.demoTest = function () { browser .url('https://nightwatchjs.org') .axeInject() .axeRun( 'body', { runOnly: ['color-contrast', 'image-alt'] } ); };

  Example 2

  this.demoTest = function () { browser .url('https://nightwatchjs.org') .axeInject() .axeRun( 'body', { 'color-contrast': { enabled: false } }, } ); };

  See Also

  • https://www.deque.com/axe/core-documentation/api-documentation/#options-parameter

  • https://nightwatchjs.org/api/axeRun.html

method closeWindow

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

• Close the current window. This can be useful when you're working with multiple windows open (e.g. an OAuth login). Uses window protocol command.

  Example 1

  describe('closeWindow command demo' , function (result) { test('demo test', function () { browser.closeWindow(); }); });

  See Also

  • https://nightwatchjs.org/api/closeWindow.html

method debug

debug: (
    config?: { useGlobal?: boolean; preview?: boolean; timeout?: number },
    callback?: (this: NightwatchAPI) => void
) => Awaitable<this, undefined>;

• This command halts the test execution and provides users with a REPL interface where they can type any of the available Nightwatch commands and the command will be executed in the running browser in real-time.

  This can be used to debug why a certain command in not working as expected, find the correct locators for your assertions or just play around with the available Nightwatch commands.

  Example 1

  // async function is required while using the debug // command to get the correct result as output. this.demoTest = async function (browser) { browser.debug();

  // with no auto-complete browser.debug({preview: false});

  // with a timeout of 6000 ms (time for which the interface // would wait for a result). browser.debug({timeout: 6000}) };

  See Also

  • https://nightwatchjs.org/api/debug.html

method deleteCookie

deleteCookie: (
    cookieName: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• Delete the cookie with the given name. This command is a no-op if there is no such cookie visible to the current page.

  Example 1

  this.demoTest = function() { browser.deleteCookie("test_cookie", function() { // do something more in here }); }

  See Also

  • https://nightwatchjs.org/api/deleteCookie.html

method deleteCookies

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

• Delete all cookies visible to the current page.

  Example 1

  this.demoTest = function() { browser.deleteCookies(function() { // do something more in here }); }

  See Also

  • https://nightwatchjs.org/api/deleteCookies.html

method end

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

• Ends the session. Uses session protocol command.

  Example 1

  this.demoTest = function () { browser.end(); };

  See Also

  • https://nightwatchjs.org/api/end.html

method fullscreenWindow

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

• Sets the current window state to fullscreen.

  Example 1

  module.exports = { 'demo Test': function(browser) { browser.fullscreenWindow(function(result) { console.log(result); }); },

  'ES6 async demo Test': async function(browser) { const result = await browser.fullscreenWindow(); console.log('result value is:', result.value); } }

  See Also

  • https://nightwatchjs.org/api/fullscreenWindow.html

method getCookie

getCookie: (
    name: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<Cookie>
    ) => void
) => Awaitable<this, Cookie>;

• Retrieve a single cookie visible to the current page. The cookie is returned as a cookie JSON object, as defined [here](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).

  Uses cookie protocol command.

  Example 1

  this.demoTest = function() { browser.getCookie(name, function callback(result) { this.assert.equal(result.value, '123456'); this.assert.equals(result.name, 'test_cookie'); }); }

  See Also

  • https://nightwatchjs.org/api/getCookie.html

method getCookies

getCookies: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<Cookie[]>
    ) => void
) => Awaitable<this, Cookie[]>;

• Retrieve all cookies visible to the current page. The cookies are returned as an array of cookie JSON object, as defined [here](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).

  Uses cookie protocol command.

  Example 1

  this.demoTest = function() { browser.getCookies(function callback(result) { this.assert.equal(result.value.length, 1); this.assert.equals(result.value[0].name, 'test_cookie'); }); }

  See Also

  • https://nightwatchjs.org/api/getCookies.html

method getCurrentUrl

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

• Retrieve the URL of the current page.

  Example 1

  describe('Navigation commands demo', function() { test('demoTest', function(browser) { // navigate to new url: browser.navigateTo('https://nightwatchjs.org');

  // Retrieve to url with callback: browser.getCurrentUrl(function(result) { console.log(result.value); }); });

  test('demoTestAsync', async function(browser) { const currentUrl = await browser.navigateTo('https://nightwatchjs.org').getCurrentUrl(); console.log('currentUrl:', currentUrl); // will print 'https://nightwatchjs.org' });

  });

  See Also

  • https://nightwatchjs.org/api/getCurrentUrl.html

method getLog

getLog: (
    typestring: string,
    callback?: (this: NightwatchAPI, log: NightwatchLogEntry[]) => void
) => Awaitable<this, NightwatchLogEntry[]>;

• Gets a log from Selenium.

  Example 1

  this.demoTest = function() { this.getLog('browser', function(logEntriesArray) { console.log('Log length: ' + logEntriesArray.length); logEntriesArray.forEach(function(log) { console.log('[' + log.level + '] ' + log.timestamp + ' : ' + log.message); }); }); };

  See Also

  • https://nightwatchjs.org/api/getLog.html

method getLogTypes

getLogTypes: (
    callback?: (this: NightwatchAPI, result: NightwatchLogTypes[]) => void
) => Awaitable<this, NightwatchLogTypes[]>;

• Gets the available log types. More info about log types in WebDriver can be found here: https://github.com/SeleniumHQ/selenium/wiki/Logging

  Example 1

  this.demoTest = function() { this.getLogTypes(function(typesArray) { console.log(typesArray); }); };

  See Also

  • https://nightwatchjs.org/api/getLogTypes.html

method getTitle

getTitle: (
    callback?: (this: NightwatchAPI, result: string) => void
) => Awaitable<this, string>;

• Returns the title of the current page. Uses title protocol command.

  Example 1

  this.demoTest = function () { browser.getTitle(function(title) { this.assert.equal(typeof title, 'string'); this.assert.equal(title, 'Nightwatch.js'); }); };

  See Also

  • https://nightwatchjs.org/api/getTitle.html

method getWindowPosition

getWindowPosition: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<WindowPosition>
    ) => void
) => Awaitable<this, WindowPosition>;

• Retrieves the current window position.

  For clients which are compatible with the [W3C Webdriver API](https://w3c.github.io/webdriver/), getWindowPosition is an alias of getWindowRect.

  The getWindowRect command returns both dimensions and position of the window, using the windowRect protocol command.

  Example 1

  module.exports = { 'demo test .getWindowPosition()': function(browser) { // Retrieve the attributes browser.getWindowPosition(function(value) { console.log(value); }); },

  'getWindowPosition ES6 demo test': async function(browser) { const value = await browser.getWindowPosition(); console.log('value', value); } }

  See Also

  • https://nightwatchjs.org/api/getWindowPosition.html

method getWindowRect

getWindowRect: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<WindowSizeAndPosition>
    ) => void
) => Awaitable<this, WindowSizeAndPosition>;

• Change or get the [window rect](https://w3c.github.io/webdriver/#dfn-window-rect). This is defined as a dictionary of the screenX, screenY, outerWidth and outerHeight attributes of the window.

  Its JSON representation is the following: - x - window's screenX attribute; - y - window's screenY attribute; - width - outerWidth attribute; - height - outerHeight attribute.

  All attributes are in in CSS pixels. To change the window react, you can either specify width and height, x and y or all properties together.

  Example 1

  module.exports = { 'demo test .getWindowRect()': function() { // Retrieve the attributes browser.getWindowRect(function(value) { console.log(value); }); },

  'getWindowRect ES6 demo test': async function() { const resultValue = await browser.getWindowRect(); console.log('result value', resultValue); } }

  See Also

  • https://nightwatchjs.org/api/getWindowRect.html

method getWindowSize

getWindowSize: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<WindowSizeAndPosition>
    ) => void
) => Awaitable<this, WindowSizeAndPosition>;

• Retrieves the current window size.

  For clients which are compatible with the [W3C Webdriver API](https://w3c.github.io/webdriver/), getWindowSize is an alias of getWindowRect.

  The getWindowRect command returns both dimensions and position of the window, using the windowRect protocol command.

  Example 1

  module.exports = { 'demo test .getWindowSize()': function() { // Retrieve the attributes browser.getWindowSize(function(value) { console.log(value); }); },

  'getWindowSize ES6 demo test': async function(browser) { const value = await browser.getWindowSize(); console.log('value', value); } }

  See Also

  • https://nightwatchjs.org/api/getWindowSize.html

method init

init: (
    url?: string,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<null>
    ) => void
) => Awaitable<this, null>;

• This command is an alias to url and also a convenience method when called without any arguments in the sense that it performs a call to .url() with passing the value of launch_url field from the settings file. Uses url protocol command.

  Example 1

  this.demoTest = function () { browser.init(); };

  See Also

  • https://nightwatchjs.org/api/init.html

method injectScript

injectScript: {
    (
        scriptUrl: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<WebElement>
        ) => void
    ): Awaitable<this, WebElement>;
    (
        scriptUrl: string,
        id: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<WebElement>
        ) => void
    ): Awaitable<this, WebElement>;
};

• Utility command to load an external script into the page specified by url.

  Example 1

  this.demoTest = function() { this.injectScript("{script-url}", function() { // we're all done here. }); };

  See Also

  • https://nightwatchjs.org/api/injectScript.html

method isLogAvailable

isLogAvailable: (
    typeString: string,
    callback?: (this: NightwatchAPI, result: boolean) => void
) => Awaitable<this, boolean>;

• Utility command to test if the log type is available.

  Example 1

  this.demoTest = function() { browser.isLogAvailable('browser', function(isAvailable) { // do something more in here }); }

  See Also

  • https://nightwatchjs.org/api/isLogAvailable.html

method maximizeWindow

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

• Maximizes the current window.

  Example 1

  this.demoTest = function () { browser.maximizeWindow(); };

  See Also

  • https://nightwatchjs.org/api/maximizeWindow.html

method minimizeWindow