@types/nightwatch

property '[attributes]'

'[attributes]': {};

property '[client]'

'[client]': NightwatchClient;

property '[instance]'

'[instance]': any;

method argv

argv: () => any;

method define

define: (name: any, value: any) => any;

method desiredCapabilities

desiredCapabilities: () => NightwatchDesiredCapabilities;

method disabled

disabled: () => boolean;

method endSessionOnFail

endSessionOnFail: () => boolean;

method globals

globals: () => NightwatchGlobals;

method name

name: () => string;

method page

page: () => any;

method retries

retries: (n: any) => void;

method retryInterval

retryInterval: (value: number) => void;

method settings

settings: () => NightwatchOptions;

method skipTestcasesOnFail

skipTestcasesOnFail: () => boolean;

method suiteRetries

suiteRetries: (n: any) => void;

method tags

tags: () => string | string[];

method timeout

timeout: (value: number) => void;

method unitTest

unitTest: () => boolean;

method waitForRetryInterval

waitForRetryInterval: (value: number) => number | void;

method waitForTimeout

waitForTimeout: (value: number) => number | void;

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 closeWindow

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

• 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

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

  See Also

  • window

method deleteCookie

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

• 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

  • cookie

method deleteCookies

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

• Delete all cookies visible to the current page.

  Example 1

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

  See Also

  • cookie

method end

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

• Ends the session. Uses session protocol command.

  Example 1

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

  See Also

  • session

method getCookie

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

• 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

  • cookie

method getCookies

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

• 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

  • cookie

method getLog

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

• 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

  • getLogTypes

method getLogTypes

getLogTypes: (
    callback?: (
        this: NightwatchAPI,
        result: Array<'client' | 'driver' | 'browser' | 'server' | 'performance'>
    ) => void
) => this;

• 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

  • sessionLogTypes

method getTitle

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

• 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

  • title

method getWindowPosition

getWindowPosition: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<{ x: number; y: number }>
    ) => void
) => this;

• 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

  • windowRect

method getWindowRect

getWindowRect: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>
    ) => void
) => this;

• 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

  • windowRect

method getWindowSize

getWindowSize: (
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>
    ) => void
) => this;

• 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); } }

method init

init: (url?: string) => this;

• 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

  • url

method injectScript

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

• 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. }); };

method isLogAvailable

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

• 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

  • getLogTypes

method maximizeWindow

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

• Maximizes the current window.

  Example 1

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

  See Also

  • windowMaximize

method pageSource

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

• Returns the page source. Uses pageSource protocol command.

  Example 1

  this.demoTest = function (browser) { browser.pageSource(function(pageSource) { console.log(pageSource); }); };

  See Also

  • pageSource

method pause

pause: (ms?: number, callback?: (this: NightwatchAPI) => void) => this;

• Suspends the test for the given time in milliseconds. If the milliseconds argument is missing it will suspend the test indefinitely

  Example 1

  this.demoTest = function () { browser.pause(1000); // or suspend indefinitely browser.pause(); };

method perform

perform: (
    callback:
        | (() => undefined | Promise<any>)
        | ((done: () => void) => void)
        | ((client: NightwatchAPI, done: () => void) => void)
) => this;

• A simple perform command which allows access to the Nightwatch API in a callback. Can be useful if you want to read variables set by other commands.

  The callback signature can have up to two parameters. - no parameters: callback runs and perform completes immediately at the end of the execution of the callback. - one parameter: allows for asynchronous execution within the callback providing a done callback function for completion as the first argument. - two parameters: allows for asynchronous execution with the Nightwatch api object passed in as the first argument, followed by the done callback.

  Example 1

  this.demoTest = function () { var elementValue; browser .getValue('.some-element', function(result) { elementValue = result.value; }) // other stuff going on ... // // self-completing callback .perform(function() { console.log('elementValue', elementValue); // without any defined parameters, perform // completes immediately (synchronously) }) // // asynchronous completion .perform(function(done) { console.log('elementValue', elementValue); // potentially other async stuff going on // on finished, call the done callback done(); }) // // asynchronous completion including api (client) .perform(function(done) { console.log('elementValue', elementValue); // similar to before, but now with client // potentially other async stuff going on // on finished, call the done callback done(); }); };

method resizeWindow

resizeWindow: (
    width: number,
    height: number,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<void>
    ) => void
) => this;

• Resizes the current window.

  Example 1

  this.demoTest = function () { browser.resizeWindow(1000, 800); };

  See Also

  • windowSize

method saveScreenshot

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

• Take a screenshot of the current page and saves it as the given filename.

  Example 1

  this.demoTest = function ( ) { browser.saveScreenshot('/path/to/fileName.png'); };

  See Also

  • screenshot

method setCookie

setCookie: (
    cookie: Cookie,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<void>
    ) => void
) => this;

• Set a cookie, specified 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.setCookie({ name : "test_cookie", value : "test_value", path : "/", (Optional) domain : "example.org", (Optional) secure : false, (Optional) httpOnly : false, // (Optional) expiry : 1395002765 // (Optional) time in seconds since midnight, January 1, 1970 UTC }); }

  See Also

  • cookie

method setWindowPosition

setWindowPosition: (
    offsetX: number,
    offsetY: number,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<void>
    ) => void
) => this;

• Sets the current window position.

  Example 1

  this.demoTest = function () { browser.setWindowPosition(0, 0); };

  See Also

  • windowPosition

method setWindowRect

setWindowRect: (
    options: windowSizeAndPosition,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<void>
    ) => void
) => this;

• Change 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 .setWindowRect()': function() {

  // Change the screenX and screenY attributes of the window rect. browser.setWindowRect({x: 500, y: 500});

  // Change the width and height attributes of the window rect. browser.setWindowRect({width: 600, height: 300});

  // Retrieve the attributes browser.setWindowRect(function(result) { console.log(result.value); }); },

  'setWindowRect ES6 demo test': async function() { await browser.setWindowRect({ width: 600, height: 300, x: 100, y: 100 }); } }

  See Also

  • windowRect

method setWindowSize

setWindowSize: (
    width: number,
    height: number,
    callback?: (
        this: NightwatchAPI,
        result: NightwatchCallbackResult<void>
    ) => void
) => this;

• Sets the current window position.

  Example 1

  this.demoTest = function () { browser.setWindowPosition(0, 0); };

  See Also

  • windowSize

method switchWindow

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

• Change focus to another window. The window to change focus to may be specified by its server assigned window handle, or by the value of its name attribute.

  To find out the window handle use windowHandles command

  Example 1

  this.demoTest = function () { browser.windowHandles(function(result) { var handle = result.value[0]; browser.switchWindow(handle); }); };

  this.demoTestAsync = async function () { const result = browser.windowHandles(); var handle = result.value[0]; browser.switchWindow(handle); };

  See Also

  • window

method urlHash

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

• Convenience command that adds the specified hash (i.e. url fragment) to the current value of the launch_url as set in nightwatch.json.

  Example 1

  this.demoTest = function () { browser.urlHash('#hashvalue'); // or browser.urlHash('hashvalue'); };

  See Also

  • url

method useCss

useCss: (callback?: (this: NightwatchAPI) => void) => this;

• Sets the locate strategy for selectors to css selector, therefore every following selector needs to be specified as css.

  Example 1

  this.demoTest = function () { browser .useCss() // we're back to CSS now .setValue('input[type=text]', 'nightwatch'); };

method useXpath

useXpath: (callback?: (this: NightwatchAPI) => void) => this;

• Sets the locate strategy for selectors to xpath, therefore every following selector needs to be specified as xpath.

  Example 1

  this.demoTest = function () { browser .useXpath() // every selector now must be xpath .click("//tr[@data-recordid]/span[text()='Search Text']"); };

property domain

domain: string | undefined;

property expiry

expiry: Date | number | undefined;

property httpOnly

httpOnly: boolean | undefined;

property name

name: string;

property path

path: string | undefined;

property secure

secure: boolean | undefined;

property value

value: string;

property browserName

browserName: string | null;

property config

config?: string;

property debug

debug?: boolean;

property devtools

devtools?: boolean;

property enable_global_apis

enable_global_apis?: boolean;

property env

env?: string;

property globals

globals?: any;

property headless

headless?: boolean;

property output

output?: boolean;

property parallel

parallel?: boolean;

property reporter

reporter?: null;

property silent

silent?: boolean;

property timeout

timeout?: number;

property useAsync

useAsync?: boolean;

property sendKeys

sendKeys: SharedCommands['setValue'];

• Alias for setValue.

  Types a key sequence on the DOM element. Can be used to send a sequence of key strokes to an element. Any UTF-8 character may be specified.

  An object map with available keys and their respective UTF-8 characters, as defined on [W3C WebDriver draft spec](https://www.w3.org/TR/webdriver/#character-types), is loaded onto the main Nightwatch instance as browser.Keys.

  Example 1

  // send some simple text to an input this.demoTest = function () { browser.sendKeys('input[type=text]', 'nightwatch'); }; // // send some text to an input and hit enter. this.demoTest = function () { browser.sendKeys('input[type=text]', ['nightwatch', browser.Keys.ENTER]); };

  See Also

  • setValue

method clearValue

clearValue: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): this;
};

• Clear a textarea or a text input element's value. Starting with v1.1 clearValue() will wait for the element to be present (until the specified timeout).

  If the element is not found, an error is thrown which will cause the test to fail. Starting with v1.2 you can suppress element not found errors by specifying the suppressNotFoundErrors flag.

  Example 1

  module.exports = { demoTest() { browser.clearValue('#login input[type=text]');

  browser.clearValue('#login input[type=text]', function(result) { console.log('clearValue result', result); });

  // with explicit locate strategy browser.clearValue('css selector', '#login input[type=text]');

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.clearValue({ selector: '#login input[type=text]', index: 1, suppressNotFoundErrors: true });

  browser.clearValue({ selector: '#login input[type=text]', timeout: 2000 // overwrite the default timeout (in ms) to check if the element is present }); } }

  See Also

  • elementIdClear

method click

click: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<null>
        ) => void
    ): this;
};

• Simulates a click event on the given DOM element. The element is scrolled into view if it is not already pointer-interactable. See the WebDriver specification for element interactability.

  Example 1

  module.exports = { demoTest() { browser.click('#main ul li a.first');

  browser.click('#main ul li a.first', function(result) { console.log('Click result', result); });

  // with explicit locate strategy browser.click('css selector', '#main ul li a.first');

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.click({ selector: '#main ul li a', index: 1, suppressNotFoundErrors: true });

  browser.click({ selector: '#main ul li a.first', timeout: 2000 // overwrite the default timeout (in ms) to check if the element is present }); },

  demoTestAsync: async function(browser) { const result = await browser.click('#main ul li a.first'); console.log('Click result', result); } }

  See Also

  • elementIdClick

method dragAndDrop

dragAndDrop: {
    (
        selector: string | ElementProperties,
        destination: NightwatchElement | { x: number; y: number },
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<void>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        destination: NightwatchElement | { x: number; y: number },
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<void>
        ) => void
    ): this;
};

• Drag an element to the given position or destination element.

  Example 1

  module.exports = { demoTest(browser) { browser.dragAndDrop('#main', {x: 100, y:100}):

  //using webElement as a destination demoTestAsync: async function(browser) { const destination = await browser.findElement('#upload'); browser.dragAndDrop('#main', destination.getId()); } }

method findElement

findElement: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                value: WebElement;
                status: number;
                WebdriverElementId: WebElement;
            }>
        ) => void
    ): WebElementPromise;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                value: WebElement;
                status: number;
                WebdriverElementId: WebElement;
            }>
        ) => void
    ): WebElementPromise;
};

• Search for an elements on the page, starting from the document root. The located element will be returned as web element JSON object (with an added .getId() convenience method). First argument is the element selector, either specified as a string or as an object (with 'selector' and 'locateStrategy' properties).

  Example 1

  module.exports = { 'demo Test': function(browser) { const resultElement = await browser.findElement('.features-container li:first-child');

  console.log('Element Id:', resultElement.getId()); },

method findElements

findElements: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                value: WebElement[];
                status: number;
                WebdriverElementId: WebElement;
            }>
        ) => void
    ): WebElement[];
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                value: WebElement[];
                status: number;
                WebdriverElementId: WebElement;
            }>
        ) => void
    ): WebElement[];
};

• Search for multiple elements on the page, starting from the document root. The located elements will be returned as web element JSON objects (with an added .getId() convenience method). First argument is the element selector, either specified as a string or as an object (with 'selector' and 'locateStrategy' properties).

  Example 1

  module.exports = { 'demo Test': function(browser) { const resultElements = await browser.findElements('.features-container li');

  resultElements.forEach(item => console.log('Element Id:', item.getId())); },

method getAccessibleName

getAccessibleName: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
};

• Returns the computed WAI-ARIA label of an element.

  Example 1

  module.exports = { demoTest() { browser.getAccessibleName('*[name="search"]', function(result) { this.assert.equal(typeof result, 'object); this.assert.equal(result.value, 'search input'); });

  // with explicit locate strategy browser.getAccessibleName('css selector', '*[name="search"]', function(result) { console.log('getAccessibleName result', result.value); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getAccessibleName({ selector: '*[name="search"]', index: 1 }, function(result) { console.log('getAccessibleName result', result.value); });

  browser.getAccessibleName({ selector: '*[name="search"]', timeout: 2000 // overwrite the default timeout (in ms) to check if the element is present }, function(result) { console.log('getAccessibleName result', result.value); }); },

  demoTestAsync: async function() { const result = await browser.getAccessibleName('*[name="search"]'); console.log('getAccessibleName result', result); } }

method getAriaRole

getAriaRole: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
};

• Returns the computed WAI-ARIA role of an element.

  Example 1

  module.exports = { demoTest(browser) { browser.getAriaRole('*[name="search"]', function(result) { this.assert.equal(typeof result, 'object'); this.assert.equal(result.value, 'combobox'); });

  // with explicit locate strategy browser.getAriaRole('css selector', '*[name="search"]', function(result) { console.log('getAriaRole result', result.value); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getAriaRole({ selector: '*[name="search"]', index: 1 }, function(result) { console.log('getAriaRole result', result.value); });

  browser.getAriaRole({ selector: '*[name="search"]', timeout: 2000 // overwrite the default timeout (in ms) to check if the element is present }, function(result) { console.log('getAriaRole result', result.value); }); },

  demoTestAsync: async function(browser) { const result = await browser.getAriaRole('*[name="search"]'); console.log('getAriaRole result', result); } }

method getAttribute

getAttribute: {
    (
        selector: string | ElementProperties,
        attribute: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string | null>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        attribute: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
};

• Retrieve the value of an attribute for a given DOM element.

  Example 1

  module.exports = { demoTest() { browser.getAttribute('#main ul li a.first', 'href', function(result) { console.log('result', result); });

  // with explicit locate strategy browser.getAttribute('css selector', '#main ul li a.first', 'href', function(result) { console.log('result', result); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getAttribute({ selector: '#main ul li a.first', index: 1, suppressNotFoundErrors: true }, 'href', function(result) { console.log('result', result); }); },

  demoTestAsync: async function(browser) { const result = await browser.getAttribute('#main ul li a.first', 'href'); console.log('attribute', result); } }

  See Also

  • elementIdAttribute

method getCssProperty

getCssProperty: {
    (
        selector: string | ElementProperties,
        cssProperty: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        cssProperty: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<string>
        ) => void
    ): this;
};

• Retrieve the value of a css property for a given DOM element.

  Example 1

  module.exports = { demoTest() { browser.getCssProperty('#main ul li a.first', 'display', function(result) { console.log('result', result); });

  // with explicit locate strategy browser.getCssProperty('css selector', '#main ul li a.first', 'display', function(result) { console.log('result', result); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getCssProperty({ selector: '#main ul li a.first', index: 1, suppressNotFoundErrors: true }, 'display', function(result) { console.log('result', result); }); },

  demoTestAsync: async function(browser) { const result = await browser.getCssProperty('#main ul li a.first', 'display'); console.log('display', result); } }

  See Also

  • elementIdCssProperty

method getElementProperty

getElementProperty: {
    (
        selector: string | ElementProperties,
        property: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<any>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        property: string,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<any>
        ) => void
    ): this;
};

• Retrieve the value of a specified DOM property for the given element. For all the available DOM element properties, consult the [Element doc at MDN](https://developer.mozilla.org/en-US/docs/Web/API/element).

  Example 1

  module.exports = { demoTest(browser) { browser.getElementProperty('#login input[type=text]', 'classList', function(result) { console.log('result', result); });

  // with explicit locate strategy browser.getElementProperty('css selector', '#login input[type=text]', 'classList', function(result) { console.log('result', result); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getElementProperty({ selector: '#login input[type=text]', index: 1, suppressNotFoundErrors: true }, 'classList', function(result) { console.log('result', result); }); },

  demoTestAsync: async function(browser) { const result = await browser.getElementProperty('#login input[type=text]', 'classList'); console.log('classList', result); } }

method getElementRect

getElementRect: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                height: number;
                width: number;
                x: number;
                y: number;
            }>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                height: number;
                width: number;
                x: number;
                y: number;
            }>
        ) => void
    ): this;
};

• Determine an element's size in pixels. For W3C Webdriver compatible clients (such as GeckoDriver), this command is equivalent to getLocation and both return the dimensions and coordinates of the given element: - x: X axis position of the top-left corner of the element, in CSS pixels - y: Y axis position of the top-left corner of the element, in CSS pixels - height: Height of the element’s bounding rectangle in CSS pixels; - width: Width of the web element’s bounding rectangle in CSS pixels.

  Example 1

  module.exports = { demoTest() { browser.getElementSize('#login', function(result) { console.log('result', result); });

  // with explicit locate strategy browser.getElementSize('css selector', '#login', function(result) { console.log('result', result); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getElementSize({ selector: '#login', index: 1, suppressNotFoundErrors: true }, function(result) { console.log('result', result); }); },

  demoTestAsync: async function() { const result = await browser.getElementSize('#login'); console.log('classList', result); } }

method getElementSize

getElementSize: {
    (
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                width: number;
                height: number;
                x: number;
                y: number;
            }>
        ) => void
    ): this;
    (
        using: LocateStrategy,
        selector: string | ElementProperties,
        callback?: (
            this: NightwatchAPI,
            result: NightwatchCallbackResult<{
                width: number;
                height: number;
                x: number;
                y: number;
            }>
        ) => void
    ): this;
};

• Determine an element's size in pixels. For W3C Webdriver compatible clients (such as GeckoDriver), this command is equivalent to getLocation and both return the dimensions and coordinates of the given element: - x: X axis position of the top-left corner of the element, in CSS pixels - y: Y axis position of the top-left corner of the element, in CSS pixels - height: Height of the element’s bounding rectangle in CSS pixels; - width: Width of the web element’s bounding rectangle in CSS pixels.

  Example 1

  module.exports = { demoTest() { browser.getElementSize('#login', function(result) { console.log('result', result); });

  // with explicit locate strategy browser.getElementSize('css selector', '#login', function(result) { console.log('result', result); });

  // with selector object - see https://nightwatchjs.org/guide#element-properties browser.getElementSize({ selector: '#login', index: 1, suppressNotFoundErrors: true }, function(result) { console.log('result', result); }); },

  demoTestAsync: async function(browser) { const result = await browser.getElementSize('#login'); console.log('classList', result); } }

  See Also

  • elementIdSize

method getLocation