Nightwatch

https://nightwatchjs.org
Admin
Nightwatch is a no-compromise test automation framework for writing, running, and debugging tests...
Tokens:195,658
Snippets:2,082
Trust Score:9.8
Update:6 months ago
Show doc for...
Tokens:
Raw
### Run Example Locally

Source: https://nightwatchjs.org/api/window/close.html

Clone the example repository, install dependencies, and run the closeWindow test locally.

```bash
git clone https://github.com/nightwatchjs/nightwatch-examples.git
cd nightwatch-examples
npm install
npx nightwatch /api/closeWindow.js
```

--------------------------------

### Initialize Android mobile helper

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Run this command in the project root to start the Android setup process.

```bash
npx @nightwatch/mobile-helper android --appium
```

--------------------------------

### Run Example Tests with Nightwatch.js

Source: https://nightwatchjs.org/guide/getting-started/installation.html

Execute the example test suite using the Nightwatch CLI. Ensure your setup is complete before running this command.

```bash
npx nightwatch ./nightwatch/examples
```

--------------------------------

### Example Extra Setup File for CucumberJS

Source: https://nightwatchjs.org/guide/third-party-runners/cucumberjs-nightwatch-integration.html

Use an extra setup file with Cucumber's `Before` hook to manually launch the browser and update capabilities. Ensure the `browser` is set on `this` for automatic closing.

```javascript
const {Before} = require('@cucumber/cucumber');

Before(async function(testCase) {
  if (!this.client) {
    console.error('Nightwatch instance was not created.');
    
    return;
  }
  
  this.client.updateCapabilities({
    testCap: 'testing'
  });
  
  this.browser = await this.client.launchBrowser();
});
```

--------------------------------

### Integrated Mock Server Setup

Source: https://nightwatchjs.org/guide/writing-tests/api-testing.html

Set up and start an integrated mock server using Nightwatch's mockserver API. This example defines a POST endpoint that returns a JSON response.

```javascript
describe('api testing with supertest in nightwatch POST', function () {
  
  let server;
  
  before(async function(client) {
    server = await client.mockserver.create();
    server.setup((app) => {
      app.post('/api/v1/datasets/', function (req, res) {
        res.status(200).json({
          id: 'test-dataset-id'
        });
      });
    });
    
    await server.start(3000);
  });
  
  after(() => {
    server.close();
  });
  
  it('demo test', async function(client) {
    const req = await server.request()
      .post('/api/v1/datasets/')
      .send({name: 'medea'})
      .set('Accept', 'application/json')
      .expect(200)
      .expect('Content-Type', /json/);
    
    await client.assert.deepStrictEqual(server.route.post('/api/v1/datasets/').requestBody, {name: 'medea'});
  });
  
});
```

--------------------------------

### Examples of .startActivity()

Source: https://nightwatchjs.org/api/appium/startActivity.html

Practical examples demonstrating how to launch a standard activity and how to launch an activity while waiting for a subsequent one.

```javascript
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'
      });
  }
};
```

--------------------------------

### Get Available Contexts (Async/Await)

Source: https://nightwatchjs.org/api/appium/getContexts.html

This example demonstrates how to get available contexts using ES6 async/await syntax for cleaner asynchronous code. Ensure your environment supports async/await.

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

--------------------------------

### Initialize project and install dependencies

Source: https://nightwatchjs.org/guide/reporters/use-junit-reporter.html

Create a new directory and install Nightwatch with the chromedriver dependency.

```bash
mkdir ./test-project && cd ./test-project
npm i nightwatch chromedriver
```

--------------------------------

### Run Nightwatch Cucumber.js Example

Source: https://nightwatchjs.org/guide/third-party-runners/cucumberjs-nightwatch-integration.html

Execute the example tests using Nightwatch and cucumber-js. Ensure Nightwatch is installed in the project.

```bash
npx nightwatch examples/cucumber-js/features/step_definition
```

--------------------------------

### Install Nightwatch-Slack-Reporter

Source: https://nightwatchjs.org/guide/reporters/use-slack-reporter.html

Install the reporter package as a development dependency in your project.

```bash
npm i nightwatch-slack-reporter --save-dev
```

--------------------------------

### Install Appium

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Install Appium as a development dependency in your project.

```bash
npm i appium --save-dev

```

--------------------------------

### Get Current Window Handle (Async/Await)

Source: https://nightwatchjs.org/api/window/getHandle.html

This example demonstrates how to use `.window.getHandle()` with async/await syntax for cleaner asynchronous code. Ensure your environment supports async/await.

```javascript
'get current window handle with ES6 async/await': async function (browser) {
    const windowHandle = await browser.window.getHandle();
    console.log('current window handle is:', windowHandle);
  }
```

--------------------------------

### Install Jest

Source: https://nightwatchjs.org/guide/third-party-test-runners/jest.html

Install the Jest testing framework as a development dependency.

```bash
npm i jest --save-dev
```

--------------------------------

### Install mocha-junit-reporter

Source: https://nightwatchjs.org/guide/third-party-runners/using-mocha.html

Command to install the mocha-junit-reporter as a development dependency.

```bash
npm i mocha-junit-reporter --save-dev
```

--------------------------------

### Start Vite Dev Server

Source: https://nightwatchjs.org/guide/component-testing/vite-plugin.html

Command to start the Vite development server for testing.

```bash
npm run dev
```

--------------------------------

### Install and Run Ava Tests

Source: https://nightwatchjs.org/guide/third-party-test-runners/ava.html

Commands to execute the configured Ava tests. Ensure Ava is installed as a development dependency.

```bash
npm test
```

```bash
npx ava
```

--------------------------------

### Install Ava dependency

Source: https://nightwatchjs.org/guide/third-party-test-runners/ava.html

Install the Ava test runner as a development dependency.

```bash
npm i ava --save-dev
```

--------------------------------

### Install Nightwatch-Allure-Reporter

Source: https://nightwatchjs.org/guide/reporters/use-nightwatch-allure-reporter.html

Install the nightwatch-allure package as a development dependency using npm.

```bash
npm i nightwatch-allure --save-dev
```

--------------------------------

### Installation and Configuration

Source: https://nightwatchjs.org/guide/component-testing/vite-plugin.html

Steps to install the vite-plugin-nightwatch and configure it in your Nightwatch and Vite projects.

```APIDOC
## Installation

### Step 1: Install the Vite Plugin

```bash
npm install vite-plugin-nightwatch
```

### Step 2: Configure Nightwatch

If you are not already using `@nightwatch/react` or `@nightwatch/vue`, update your `nightwatch.conf.js` to include the plugin:

```javascript
// nightwatch.conf.js
module.exports = {
  plugins: ['vite-plugin-nightwatch']
}
```

### Step 3: Configure Vite

Update your Vite configuration file (`vite.config.js` or similar):

```javascript
// vite.config.js
import { defineConfig } from 'vite'
import nightwatchPlugin from 'vite-plugin-nightwatch'

export default defineConfig({
  plugins: [
    // ... other plugins
    nightwatchPlugin()
  ]
})
```

**Note:** Nightwatch assumes the Vite dev server is running on `http://localhost:3000`. You can change this using `launchUrl` or `baseUrl` in `nightwatch.conf.js`. Start the Vite dev server with `npm run dev`.
```

--------------------------------

### Install and use NPM-based reporter

Source: https://nightwatchjs.org/guide/reporters/create-custom-reporter.html

Commands to install and invoke a custom reporter published as an NPM package.

```bash
npm i <nightwatch-custom-reporter>
```

```bash
nightwatch --reporter=<nightwatch-custom-reporter>
```

--------------------------------

### Install Appium

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Add Appium 2 as a development dependency to the project.

```bash
npm i appium --save-dev
```

--------------------------------

### Example: Mocking Google Search Response

Source: https://nightwatchjs.org/api/network/mockResponse.html

This example demonstrates how to intercept a request to Google's homepage and provide a custom 'Hello there!' response. Ensure the .network.mockResponse() command is called before navigating to the URL.

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

```

--------------------------------

### Get CSS Property - TypeScript Example

Source: https://nightwatchjs.org/api/element/getCssProperty.html

An example using TypeScript syntax to get a CSS property value and assert its expected value.

```typescript
export default {
  demoTest(browser: NightwatchAPI): void {
    browser.element('#main ul li a.first').getCssProperty('display')
      .assert.valueEquals('block');
  },
  async demoTestAsync(browser: NightwatchAPI): Promise<void> {
    const result = await browser.element('#main ul li a.first').getCssProperty('display');
    console.log('display', result);
  }
}
```

--------------------------------

### Example usage of .window.fullscreen()

Source: https://nightwatchjs.org/api/window/fullscreen.html

Demonstrates both callback and async/await implementations for setting the window to fullscreen.

```javascript
module.exports = {
 'make current window fullscreen': function (browser) {
    browser.window.fullscreen(function () {
      console.log('window in fullscreen mode');
    });
  },

  'make current window fullscreen with ES6 async/await': async function (browser) {
    await browser.window.fullscreen();
  }
}
```

--------------------------------

### Confirm Package Installation Prompt

Source: https://nightwatchjs.org/guide/getting-started/installation.html

When prompted during the 'npm init nightwatch' command, press 'y' to confirm the installation of the 'create-nightwatch' package, which is required for setup.

```bash
❯ npm init nightwatch
Need to install the following packages:
  create-nightwatch
Ok to proceed? (y)
```

--------------------------------

### Example: Taking a heap snapshot

Source: https://nightwatchjs.org/api/takeHeapSnapshot.html

Demonstrates navigating to a URL and saving a heap snapshot to a local file.

```javascript
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');
   });
 });
```

--------------------------------

### Example: Input basic auth credentials

Source: https://nightwatchjs.org/api/registerBasicAuth.html

Demonstrates how to register credentials before navigating to a protected URL.

```javascript
module.exports = {
  'input basic auth credentials': function (browser) {
    browser
      .registerBasicAuth('admin', 'admin')
      .navigateTo('https://the-internet.herokuapp.com/basic_auth');
  }
};
```

--------------------------------

### Get Window Position (Async/Await)

Source: https://nightwatchjs.org/api/window/getPosition.html

This example demonstrates how to get the current window's position using async/await syntax. It directly returns the 'x' and 'y' coordinates.

```javascript
module.exports = {
  'get current window position using ES6 async/await': async function (browser) {
     const {x, y} = await browser.window.getPosition();
     console.log('Position of current window:', x, y);
  }
}
```

--------------------------------

### Set window size implementation examples

Source: https://nightwatchjs.org/api/window/setSize.html

Demonstrates resizing the window using both a callback function and ES6 async/await syntax.

```javascript
module.exports = {
  'set current window size': function (browser) {
     browser.window.setSize(1024, 768, function (result) {
       console.log('window resized successfully');
     });
  },

  'set current window size using ES6 async/await': async function (browser) {
     await browser.window.setSize(1024, 768);
  }
}
```

--------------------------------

### Navigate using .init()

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

Use this command to initialize the browser session by navigating to the default launch URL.

```javascript
this.demoTest = function (client) {
  client.init();
};
```

--------------------------------

### Activity Management API

Source: https://nightwatchjs.org/guide/mobile-app-testing/commands.html

Commands to start, get current, and manage application activities.

```APIDOC
## POST /appium/startActivity

### Description
Starts a new Activity within the application.

### Method
POST

### Endpoint
/appium/startActivity

### Parameters
#### Request Body
- **appPackage** (String) - Required - Name of the application package.
- **appActivity** (String) - Required - Name of the activity to start.
- **appWaitPackage** (String) - Optional - Automation will begin after this package starts.
- **appWaitActivity** (String) - Optional - Automation will begin after this activity starts.
- **intentAction** (String) - Optional - Intent action to use for starting the activity.
- **intentCategory** (String) - Optional - Intent category to use for starting the activity.
- **intentFlags** (String) - Optional - Flags to use for starting the activity.
- **optionalIntentArguments** (String) - Optional - Additional arguments for the intent.
- **dontStopAppOnReset** (Boolean) - Optional - Whether to stop the app on reset.

### Request Example
```json
{
  "appPackage": "com.example",
  "appActivity": "Activity"
}
```

## GET /appium/currentActivity

### Description
Retrieves the name of the current activity.

### Method
GET

### Endpoint
/appium/currentActivity

### Response
#### Success Response (200)
- **activity** (String) - The name of the current activity.

### Response Example
```json
{
  "activity": "com.example.MainActivity"
}
```

## GET /appium/currentPackage

### Description
Retrieves the name of the current application package.

### Method
GET

### Endpoint
/appium/currentPackage

### Response
#### Success Response (200)
- **package** (String) - The name of the current application package.

### Response Example
```json
{
  "package": "com.example.app"
}
```
```

--------------------------------

### Maximize window implementation examples

Source: https://nightwatchjs.org/api/window/maximize.html

Demonstrates maximizing the browser window using both a callback function and ES6 async/await syntax.

```javascript
module.exports = {
 'maximize current window': function (browser) {
    browser.window.maximize(function () {
      console.log('window maximized successfully');
    });
  },

  'maximize current window using ES6 async/await': async function (browser) {
    await browser.window.maximize();
  }
}
```

--------------------------------

### Example Nightwatch Configuration File

Source: https://nightwatchjs.org/guide/configuration/nightwatch-configuration-file.html

This example configures Nightwatch to use Firefox as the target browser and assumes `geckodriver` is installed. It specifies the location of test source folders and webdriver settings.

```javascript
module.exports = {
  // An array of folders (excluding subfolders) where your tests are located;
  // if this is not specified, the test source must be passed as the second argument to the test runner.
  src_folders: [],
  
  webdriver: {
    start_process: true,
    port: 4444,
    server_path: require('geckodriver').path,
    cli_args: [
      // very verbose geckodriver logs
      // '-vv'
    ]
  },
  
  test_settings: {
    default: {
      launch_url: 'https://nightwatchjs.org',
      desiredCapabilities : {
        browserName : 'firefox'
      }
    }
  }
};
```

--------------------------------

### Initialize project with app mode

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Use this command to specifically initiate a project configured for mobile app testing.

```bash
npm init nightwatch@latest <foldername> -- --app 
```

--------------------------------

### Switch to another window - Async/Await style

Source: https://nightwatchjs.org/api/window/switchTo.html

This example demonstrates switching to another window using modern async/await syntax. It's crucial to wait for the new window handle to be available before attempting to switch.

```javascript
'switch to another window with ES6 async/await': async function (browser) {
    await browser.navigateTo('https://nightwatchjs.org/__e2e/window/');
    await browser.click('#openWindowBttn');

    // wait until window handle for the new window is available
    await browser.waitUntil(async function () {
      const windowHandles = await browser.window.getAllHandles();

      return windowHandles.length === 2;
    });

    const originalWindow = await browser.window.getHandle();
    const allWindows = await browser.window.getAllHandles();

    // loop through available windows to find the new window handle
    for (const windowHandle of allWindows) {
      if (windowHandle !== originalWindow) {
        await browser.window.switchTo(windowHandle);
        break;
      }
    }

    const currentWindow = await browser.window.getHandle();
    await browser.assert.notEqual(currentWindow, originalWindow);
  }
```

--------------------------------

### Run Nightwatch globally

Source: https://nightwatchjs.org/guide/running-tests/nightwatch-runner.html

Execute the nightwatch binary when installed globally.

```bash
nightwatch [source] [options]
```

--------------------------------

### Get CSS Property - Async/Await Example

Source: https://nightwatchjs.org/api/element/getCssProperty.html

Demonstrates how to retrieve a CSS property value asynchronously using async/await and log it to the console.

```javascript
export default {
  demoTest({ element }) {
    element('#main ul li a.first')
      .getCssProperty('display')
      .assert.valueEquals('block');
  },

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

--------------------------------

### Initialize Nightwatch Project

Source: https://nightwatchjs.org

Use this command to set up a new Nightwatch project. It installs all necessary dependencies and configurations.

```bash
npm init nightwatch
```

--------------------------------

### GET .findAllByText()

Source: https://nightwatchjs.org/api/element/findAllByText.html

Search for elements on the page that contain a specified text. Elements can be searched by using another element as the starting point.

```APIDOC
## .findAllByText()

### Description
Search for elements on the page that contain a specified text. By default, the provided text is treated as a substring. Use the exact option for precise matching.

### Usage
browser.element.findAllByText(text, [options])

### Parameters
- **text** (string) - Required - The text content to search for.
- **options** (object) - Optional - Configuration object. Use `{ exact: true }` for exact comparison.

### Returns
- **Array.<ScopeWebElement>** - An array of elements matching the criteria.

### Example
```typescript
// Search by the substring matching.
const inputs = browser.element.findAllByText('group of people');

// Search for the exact occurrence.
const images = browser.element.findAllByText(
  'The nostalgic office',
  { exact: true }
);
```
```

--------------------------------

### Extended Form Story with Nightwatch hooks

Source: https://nightwatchjs.org/guide/component-testing/storybook-component-testing.html

A comprehensive example of a Form story using setup, teardown, and render hooks alongside interaction and test functions.

```javascript
import { userEvent, within } from '@storybook/testing-library';
import Form from './Form.jsx';

export default {
  title: 'Form',
  component: Form,
  
  async setup(browser) {
    console.log('setup hook', browser.capabilities)
  },
  
  async preRender(browser) {
    console.log('preRender hook')
  },
  
  async postRender(browser) {
    console.log('postRender hook')
  },
  
  async teardown(browser) {
    console.log('teardown hook')
  },
}

const Template = (args) =< <Form {...args} />;

// Component story for an empty form
export const EmptyForm = Template.bind({});

// Component story simulating filling in the form
export const FilledForm = Template.bind({});

FilledForm.play = async ({ canvasElement }) =< {
  
  // Starts querying the component from its root element
  const canvas = within(canvasElement);
  
  // 👇 Simulate interactions with the component
  await userEvent.type(canvas.getByTestId('new-todo-input'), 'outdoors hike');
  await userEvent.click(canvas.getByRole('button'));
};

FilledForm.test = async (browser, { component }) =< {
  // 👇 Run commands and assertions in the Nightwatch context
  await expect(component).to.be.visible;
}
```

--------------------------------

### Setup Android Emulator Environment

Source: https://nightwatchjs.org/guide/mobile-web-testing/upgrade-chrome-on-emulator.html

Initializes the Android emulator environment using the Nightwatch mobile helper.

```bash
npx @nightwatch/mobile-helper android
```

--------------------------------

### Chai Expect Assertion Example

Source: https://nightwatchjs.org/guide/mobile-app-testing/introduction-writing-tests.html

Integrate Chai's 'expect' style assertions for more flexible and readable test validation within your Nightwatch.js mobile app tests. Requires Chai to be installed.

```javascript
app.appium.getCurrentActivity(function(activity) {
    expect(activity.value).to.equal('.page.PageActivity')
})
```

--------------------------------

### Initialize Nightwatch Project

Source: https://nightwatchjs.org/guide/browser-extension-testing/chrome-extension.html

Run this command in your project directory to set up Nightwatch. Ensure you select 'Chrome' as the browser during the prompt.

```bash
cd /path/to/project/directory
npm init nightwatch

```

--------------------------------

### Get current window rect using ES6 async/await

Source: https://nightwatchjs.org/api/window/getRect.html

This example demonstrates how to retrieve the current window's size and position using modern ES6 async/await syntax. It destructures the result directly into width, height, x, and y variables.

```javascript
module.exports = {
  'get current window rect using ES6 async/await': async function (browser) {
     const {width, height, x, y} = await browser.window.getRect();
     console.log('Size of current window:', width, height);
     console.log('Position of current window:', x, y);
  }
}
```

--------------------------------

### Initialize Nightwatch in an Existing Project

Source: https://nightwatchjs.org/guide/getting-started/installation.html

Navigate to your existing project directory and run this command to integrate Nightwatch. You will be prompted to confirm the installation of the 'create-nightwatch' package.

```bash
cd <directory-name> 
npm init nightwatch
```

--------------------------------

### React Component Test with Interaction Hooks

Source: https://nightwatchjs.org/guide/component-testing/write-jsx-react-tests.html

An example of a React component test file that includes global and component-level test hooks like `setup`, `teardown`, `preRender`, `postRender`, `play`, and `test`. The `play()` function utilizes DOM utilities from Testing Library for interactions.

```jsx
import { fireEvent, within } from '@testing-library/dom';
import Form from '../components/Form.jsx';

export default {
  title: 'Form Component',
  component: Form,
  
  // executed before all the individual component stories; runs in Node context
  async setup(browser) {
    console.log('global setup hook', browser.capabilities)
  },
  
  // executed after all the individual component stories; runs in Node context
  async teardown(browser) {
    console.log('global teardown hook')
  },
  
  // executed before each individual component story; runs in Node context
  async preRender(browser, context) {
    // context is made of {id, name, title}
    console.log('preRender', context.id);
  },
  
  // executed after each individual component story; runs in Node context
  async postRender(browser, context) {
    // context is made of {id, name, title}
    console.log('postRender', context.id);
  }
}

export const AnotherForm = Object.assign(() => <Form addTask={function(value) {
  console.log('Add Task', value);
}} />, {
  async preRender() {},
  
  async postRender() {
    console.log('after mount', window);
  },
  
  async play({canvasElement, args}) {
    console.log('play function', args);
    
    const root = within(canvasElement);
    const input = root.getByTestId('new-todo-input');
    
    
    fireEvent.change(input, {
      target: {
        value: 'another one bites the dust'
      }
    });
    
    return {
      fromPlay: input
    }
  },
  
  test: async (browser, {component, result}) => {
    console.log('Result from play', result)
    await expect(component).to.be.visible;
    
    await expect(component.find('input')).to.have.property('value').equal('another one bites the dust');
  }
});

```

--------------------------------

### Usage of .startActivity()

Source: https://nightwatchjs.org/api/appium/startActivity.html

Basic syntax for invoking the startActivity command.

```javascript
                    .appium.startActivity(opts, [callback])
                
```

--------------------------------

### Examples of .window.setRect()

Source: https://nightwatchjs.org/api/window/setRect.html

Demonstrates setting window dimensions and positions using both standard callback-based syntax and ES6 async/await.

```javascript
module.exports = {
  'set current window rect': function (browser) {
     // Change the screenX and screenY attributes of the window rect.
     browser.window.setRect({x: 500, y: 500});

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

  'set current window rect using ES6 async/await': async function (browser) {
     // Change all attributes of the window rect at once.
     await browser.window.setRect({
       width: 600,
       height: 300,
       x: 100,
       y: 100
     });
  }
}
```

--------------------------------

### Example: Collecting performance metrics

Source: https://nightwatchjs.org/api/enablePerformanceMetrics.html

Demonstrates enabling metrics, navigating to a URL, and retrieving the collected data.

```javascript
 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);
         }
       });
   });
 });
```

--------------------------------

### Example usage of .pressKeyCode()

Source: https://nightwatchjs.org/api/appium/pressKeyCode.html

Demonstrates pressing keys with specific meta states and using the command with ES6 async/await syntax.

```javascript
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);
  }
};
```

--------------------------------

### POST .startActivity()

Source: https://nightwatchjs.org/api/appium/startActivity.html

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

```APIDOC
## .startActivity()

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

### Method
POST

### Parameters
#### Request Body
- **opts** (object) - Required - Options to start the activity with. `appPackage` and `appActivity` are required, others are optional.
- **callback** (function) - Optional - Optional callback function to be called when the command finishes.

### Request Example
{
  "appPackage": "com.android.chrome",
  "appActivity": "com.google.android.apps.chrome.Main"
}

### Response
#### Success Response (200)
- **result** (null) - Returns null upon successful execution.
```

--------------------------------

### Install CucumberJS

Source: https://nightwatchjs.org/guide/third-party-runners/cucumberjs-nightwatch-integration.html

Install the Cucumber.js library as a development dependency in your project.

```bash
npm i @cucumber/cucumber --save-dev
```

--------------------------------

### Setup Mock Server Route

Source: https://nightwatchjs.org/guide/writing-tests/api-testing.html

Configures a mock server instance with a specific route definition using an Express-like app object.

```javascript
await mockServer.setup((app) => {
    app.get('/api/v1/schemas', function (req, res) {
      console.log('GET /api/v1/schemas called');
      
      res.status(200).json([
        {
          id: 'test-schema-id1'
        },
        {
          id: 'test-schema-id2'
        }
      ]);
    })
  });
```

--------------------------------

### Initialize Nightwatch Project

Source: https://nightwatchjs.org/guide/quickstarts/create-and-run-a-test-with-selenium-server.html

Use npm to create a new Nightwatch project in a specified directory. This command installs Nightwatch and prompts for configuration preferences.

```bash
mkdir <directory-name>
cd <directory-name>
npm init nightwatch@latest
```

```bash
npm init nightwatch <directory-name>
```

--------------------------------

### Install @nightwatch/react plugin

Source: https://nightwatchjs.org/guide/component-testing/testing-react-components.html

Install the required plugin via NPM.

```bash
npm install @nightwatch/react
```

--------------------------------

### Run Cucumber with Extra Setup File

Source: https://nightwatchjs.org/guide/third-party-runners/cucumberjs-nightwatch-integration.html

Execute Cucumber tests with an additional setup file using the `--require` CLI argument, pointing to your custom setup script.

```bash
nightwatch examples/cucumber-js/features/step_definitions --require {/full/path/to/_extra_setup.js}
```

--------------------------------

### Minimize window implementation examples

Source: https://nightwatchjs.org/api/window/minimize.html

Demonstrates how to use .window.minimize() within a Nightwatch test using both traditional callbacks and modern async/await syntax.

```javascript
module.exports = {
 'minimize current window': function (browser) {
    browser.window.minimize(function () {
      console.log('window minimized successfully');
    });
  },

  'minimize current window using ES6 async/await': async function (browser) {
    await browser.window.minimize();
  }
}
```

--------------------------------

### Test Directory Structure Example

Source: https://nightwatchjs.org/guide/running-tests/using-with-test-groups.html

Illustrates how to organize test files into groups using sub-folders within the 'tests' directory. The folder names define the test groups.

```bash
lib/
  ├── selenium-server-standalone.jar
custom-commands/
  ├── loginUser.js
  ├── attachPicture.js
tests/
  ├── logingroup
  |   ├── login_test.js
  |   └── otherlogin_test.js
  ├── addressbook
  |   ├── addressbook_test.js
  |   └── contact_test.js
  ├── chat
  |   ├── chatwindow_test.js
  |   ├── chatmessage_test.js
  |   └── otherchat_test.js
  └── smoketests
      ├── smoke_test.js
      └── othersmoke_test.js

```

--------------------------------

### Install Nightwatch VRT Plugin

Source: https://nightwatchjs.org/guide/writing-tests/visual-regression-testing.html

Install the required plugin as a development dependency.

```bash
npm i @nightwatch/vrt --save-dev
```

--------------------------------

### Install Test Doubles Plugin

Source: https://nightwatchjs.org/guide/writing-tests/test-doubles.html

Install the required dependency via NPM.

```bash
npm i @nightwatch/testdoubles --save-dev
```

--------------------------------

### Connect to Emulator

Source: https://nightwatchjs.org/guide/mobile-web-testing/upgrade-chrome-on-emulator.html

Establishes a connection to the running Android emulator.

```bash
npx @nightwatch/mobile-helper android connect --emulator
```

--------------------------------

### Install jest-environment-nightwatch

Source: https://nightwatchjs.org/guide/third-party-test-runners/jest.html

Install the required environment package to bridge Nightwatch and Jest.

```bash
npm i jest-environment-nightwatch --save-dev
```

--------------------------------

### Install iOS Mobile Helper

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Run this command in your Nightwatch project directory to set up the mobile helper for iOS.

```bash
npx @nightwatch/mobile-helper ios --setup

```

--------------------------------

### Install System Image with Play Store

Source: https://nightwatchjs.org/guide/mobile-web-testing/upgrade-chrome-on-emulator.html

Downloads a system image that includes Google Play Store support.

```bash
npx @nightwatch/mobile-helper android install --system-image
```

--------------------------------

### Create Nightwatch environment setup file

Source: https://nightwatchjs.org/guide/third-party-test-runners/ava.html

Define a helper module to initialize the Nightwatch client and manage browser lifecycle within Ava tests.

```javascript
const Nightwatch = require('nightwatch');

const createNightwatchClient = function({
  headless = true,
  browserName = undefined,
  silent = true,
  verbose = false,
  output = true,
  env = null,
  parallel = false,
  devtools = false,
  debug = false,
  persistGlobals = true,
  configFile = './nightwatch.conf.js',
  globals = {},
  webdriver = {},
  timeout = null,
  enableGlobalApis = false,
  reporter = null,
  alwaysAsync = true,
  desiredCapabilities = {}
} = {}) {

  const client = Nightwatch.createClient({
    headless,
    browserName,
    reporter,
    env,
    timeout,
    parallel,
    output,
    devtools,
    debug,
    enable_global_apis: enableGlobalApis,
    silent: silent && !verbose,
    always_async_commands: alwaysAsync,
    webdriver,
    persist_globals: persistGlobals,
    config: configFile,
    globals,
    desiredCapabilities
  });

  client.updateCapabilities(desiredCapabilities);

  return client.launchBrowser();
};

module.exports = async (t, run) => {
 global.browser = await createNightwatchClient();
 try {
   await run(t);
 } finally {
   await global.browser.end();
 }
};
```

--------------------------------

### Install UiAutomator2 driver

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Install the required Appium driver for Android automation.

```bash
npx appium driver install uiautomator2
```

--------------------------------

### Install Mochawesome via NPM

Source: https://nightwatchjs.org/guide/reporters/use-mochawesome-reporter.html

Install the mochawesome package as a development dependency.

```bash
npm i mochawesome --save-dev
```

--------------------------------

### Initialize Nightwatch in a New Project

Source: https://nightwatchjs.org/guide/getting-started/installation.html

Use this command to set up Nightwatch in a new project directory. It initializes the project and installs necessary dependencies.

```bash
npm init nightwatch <directory-name>
```

--------------------------------

### Setup POST Route

Source: https://nightwatchjs.org/guide/writing-tests/api-testing.html

Configures a POST endpoint on the mock server to return a JSON response.

```javascript
await mockServer.setup((app) => {
  app.post('/api/v1/datasets/', function (req, res) {
    res.status(200).json({
      id: 'test-dataset-id'
    });
  });
});
```

--------------------------------

### Install Vite Plugin

Source: https://nightwatchjs.org/guide/component-testing/vite-plugin.html

Install the required Nightwatch Vite plugin via NPM.

```bash
npm install vite-plugin-nightwatch
```

--------------------------------

### Nightwatch Promises in Callbacks Example

Source: https://nightwatchjs.org/api/commands

Shows how Nightwatch handles Promises returned from callback functions. The test runner waits for the Promise to settle before proceeding. This example includes both a Promise-based callback and an async/await example.

```javascript
module.exports = {
  demoTest: function (browser) {
    browser
      .init()
      .getText("#main ul li", function(result) {
        return new Promise(function(resolve, reject) {
          setTimeout(function() {
            console.log('Value:', result.value);
            resolve();
          }, 1000);
        });
      })
      .click('#login button');
  },
  
  demoTestAsync: async function(browser) {
    const text = await browser.init().getText("#main ul li", function(result) {
      return Promise.resolve(result.value);
    });              
    
    console.log('The text is', text);
  }
};
```

--------------------------------

### Install @nightwatch/apitesting Plugin

Source: https://nightwatchjs.org/guide/writing-tests/api-testing.html

Install the API testing plugin using npm. This is a development dependency.

```bash
npm i @nightwatch/apitesting --save-dev
```

--------------------------------

### Initialize Storybook

Source: https://nightwatchjs.org/guide/component-testing/storybook-component-testing.html

Command to initialize Storybook in an existing React project.

```bash
npx storybook init
```

--------------------------------

### Install Nightwatch Teamcity Reporter

Source: https://nightwatchjs.org/guide/reporters/use-teamcity-reporter.html

Install the nightwatch-teamcity package as a development dependency using npm.

```bash
npm i nightwatch-teamcity --save-dev
```

--------------------------------

### Example usage of .hideKeyboard()

Source: https://nightwatchjs.org/api/appium/hideKeyboard.html

Demonstrates both standard callback and ES6 async/await patterns for hiding the keyboard.

```javascript
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();
  }
};
```

--------------------------------

### Install Appium XCUITest Driver

Source: https://nightwatchjs.org/guide/mobile-app-testing/installation.html

Install the necessary driver for Appium to interact with iOS applications.

```bash
npx appium driver install xcuitest

```

--------------------------------

### Install Plugin via NPM

Source: https://nightwatchjs.org/guide/extending-nightwatch/adding-plugins.html

Command to install a published Nightwatch plugin as a development dependency.

```bash
npm i my-new-plugin --save-dev
```

--------------------------------

### Retrieve window handles with .window.getAllHandles()

Source: https://nightwatchjs.org/api/window/getAllHandles.html

Demonstrates usage of the command using both a callback function and ES6 async/await syntax.

```javascript
module.exports = {
 'get all window handles': function (browser) {
    browser.window.getAllHandles(function (result) {
      console.log('available window handles are:', result.value);
    });
  },

  'get all window handles with ES6 async/await': async function (browser) {
    const windowHandles = await browser.window.getAllHandles();
    console.log('available window handles are:', windowHandles);
  }
}
```

--------------------------------

### Example of .sendKeys() in a test

Source: https://nightwatchjs.org/api/element/sendKeys.html

Demonstrates using .sendKeys() within both synchronous and asynchronous test functions.

```javascript
export default {
  demoTest(browser: NightwatchAPI): void {
    browser.element('input[type=text]').sendKeys('nightwatch');
  },

  async demoTestAsync(browser: NightwatchAPI): Promise<void> {
    browser.element('input[type=text]').sendKeys('nightwatch');
  }
}
```

--------------------------------

### Install geckodriver NPM Package

Source: https://nightwatchjs.org/guide/browser-drivers/geckodriver.html

Install the geckodriver NPM package as a development dependency in your project.

```bash
npm install geckodriver --save-dev
```

--------------------------------

### Browser Capabilities Example

Source: https://nightwatchjs.org/api

An example of browser capabilities object used for configuring browser instances.

```javascript
{
    browserName: 'chrome',
    'goog:chromeOptions': {},
    name: 'Example Test'
  }
```

--------------------------------

### Example of .uploadFile() implementation

Source: https://nightwatchjs.org/api/uploadFile.html

Demonstrates uploading a PDF file to an input field identified by a CSS selector.

```javascript
// send a file to for upload to a field.
this.demoTest = function (browser) {
  browser.uploadFile('#myFile', '/path/file.pdf');
};
```

--------------------------------

### Example Usage of .timeouts()

Source: https://nightwatchjs.org/api/timeouts.html

Demonstrates setting a script timeout and retrieving current timeout settings using a callback.

```javascript
 this.demoTest = function (browser) {
   browser.timeouts('script', 10000, function(result) {
     console.log(result);
   });

   browser.timeouts(function(result) {
     console.log('timeouts', result);
   });
}
```

--------------------------------

### Install Nightwatch Storybook plugin

Source: https://nightwatchjs.org/guide/component-testing/storybook-component-testing.html

Command to install the official Nightwatch Storybook plugin via NPM.

```bash
npm i @nightwatch/storybook --save-dev
```

--------------------------------

### Example implementation of .getLogTypes()

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

Demonstrates how to retrieve and log the available log types within a test case.

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

--------------------------------

### Install Chromedriver Dependency

Source: https://nightwatchjs.org/guide/mobile-app-testing/running-tests.html

Install the latest chromedriver package required for hybrid mobile app testing.

```bash
npm i chromedriver@latest --save-dev
```

--------------------------------

### Select execution environment

Source: https://nightwatchjs.org/guide/getting-started/quickstart.html

Choose whether to run tests locally, on a remote service, or both.

```text
? Select where to run Nightwatch tests (Use arrow keys)   

❯ On localhost   

  On a remote/cloud service   

  Both
```
Tokens:
Raw