Showing preview only (5,200K chars total). Download the full file or copy to clipboard to get everything.
Repository: nightwatchjs/nightwatch
Branch: main
Commit: 86d8086cc0f1
Files: 1247
Total size: 4.7 MB
Directory structure:
gitextract_4_y53lij/
├── .eslintignore
├── .eslintrc
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.yml
│ │ ├── config.yml
│ │ └── feature-request.yml
│ ├── PULL_REQUEST_TEMPLATE.md
│ ├── label-commenter-config.yml
│ ├── stale.yml
│ └── workflows/
│ ├── build-node.yaml
│ ├── component-tests.yaml
│ ├── coverage.yml
│ ├── label-commenter.yml
│ ├── missing-types-comment.yml
│ ├── missing-types.yml
│ ├── nightly.yml
│ ├── publish.yml
│ └── type-declaration-tests.yml
├── .gitignore
├── .husky/
│ └── pre-commit
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE.md
├── README.md
├── api/
│ ├── README.md
│ └── index.js
├── bin/
│ ├── .gitignore
│ ├── nightwatch
│ ├── runner.js
│ └── show_survey.js
├── codecov.yml
├── examples/
│ ├── .gitignore
│ ├── cucumber-js/
│ │ ├── README.md
│ │ └── features/
│ │ ├── nightwatch.feature
│ │ └── step_definitions/
│ │ └── nightwatch.js
│ ├── custom-assertions/
│ │ └── testCustomAssertion.js
│ ├── custom-commands/
│ │ ├── angular/
│ │ │ └── getElementsInList.js
│ │ └── strictClick.js
│ ├── globals.json
│ ├── globalsModule.js
│ ├── pages/
│ │ ├── google/
│ │ │ ├── consent.js
│ │ │ ├── search.js
│ │ │ └── searchResults.js
│ │ └── nightwatchFeatures.js
│ ├── test-app/
│ │ ├── globals.js
│ │ ├── index.html
│ │ └── page2.html
│ ├── tests/
│ │ ├── README.md
│ │ ├── angularTodoTest.js
│ │ ├── bstackdemo/
│ │ │ ├── auth.js
│ │ │ └── checkout.js
│ │ ├── chromeCDP_example.js
│ │ ├── duckDuckGo.js
│ │ ├── ecosia.js
│ │ ├── element/
│ │ │ ├── dragAndDrop.js
│ │ │ ├── elementScreenshot.js
│ │ │ ├── elementapi-tests.js
│ │ │ └── isCommands.js
│ │ ├── google.js
│ │ ├── googlePageObject.js
│ │ ├── sample-with-relative-locators.js
│ │ ├── selectElement.js
│ │ ├── shadowRootExample.js
│ │ └── vueTodoList.js
│ ├── tsconfig.json
│ └── unittests/
│ ├── demoTestAsync.js
│ ├── testUtils.js
│ └── testUtilsWithChai.js
├── index.js
├── lib/
│ ├── api/
│ │ ├── _loaders/
│ │ │ ├── _base-loader.js
│ │ │ ├── _command-loader.js
│ │ │ ├── assertion-scheduler.js
│ │ │ ├── assertion.js
│ │ │ ├── chrome.js
│ │ │ ├── command.js
│ │ │ ├── element-api.js
│ │ │ ├── element-command.js
│ │ │ ├── element-global.js
│ │ │ ├── ensure.js
│ │ │ ├── expect-assertion.js
│ │ │ ├── expect.js
│ │ │ ├── firefox.js
│ │ │ ├── page-object.js
│ │ │ ├── plugin.js
│ │ │ ├── static.js
│ │ │ └── within-context.js
│ │ ├── assertions/
│ │ │ ├── _assertionInstance.js
│ │ │ ├── attributeContains.js
│ │ │ ├── attributeEquals.js
│ │ │ ├── attributeMatches.js
│ │ │ ├── contains.js
│ │ │ ├── containsText.js
│ │ │ ├── cssClassNotPresent.js
│ │ │ ├── cssClassPresent.js
│ │ │ ├── cssProperty.js
│ │ │ ├── domPropertyContains.js
│ │ │ ├── domPropertyEquals.js
│ │ │ ├── domPropertyMatches.js
│ │ │ ├── elementNotPresent.js
│ │ │ ├── elementPresent.js
│ │ │ ├── elementsCount.js
│ │ │ ├── enabled.js
│ │ │ ├── hasAttribute.js
│ │ │ ├── hasClass.js
│ │ │ ├── hasDescendants.js
│ │ │ ├── hidden.js
│ │ │ ├── promisedValue.js
│ │ │ ├── selected.js
│ │ │ ├── textContains.js
│ │ │ ├── textEquals.js
│ │ │ ├── textMatches.js
│ │ │ ├── title.js
│ │ │ ├── titleContains.js
│ │ │ ├── titleEquals.js
│ │ │ ├── titleMatches.js
│ │ │ ├── urlContains.js
│ │ │ ├── urlEquals.js
│ │ │ ├── urlMatches.js
│ │ │ ├── value.js
│ │ │ ├── valueContains.js
│ │ │ ├── valueEquals.js
│ │ │ └── visible.js
│ │ ├── client-commands/
│ │ │ ├── _base-command.js
│ │ │ ├── _locateStrategy.js
│ │ │ ├── alerts/
│ │ │ │ ├── accept.js
│ │ │ │ ├── dismiss.js
│ │ │ │ ├── getText.js
│ │ │ │ └── setText.js
│ │ │ ├── axeInject.js
│ │ │ ├── axeRun.js
│ │ │ ├── cookies/
│ │ │ │ ├── delete.js
│ │ │ │ ├── deleteAll.js
│ │ │ │ ├── get.js
│ │ │ │ ├── getAll.js
│ │ │ │ └── set.js
│ │ │ ├── debug.js
│ │ │ ├── deleteCookie.js
│ │ │ ├── deleteCookies.js
│ │ │ ├── document/
│ │ │ │ ├── executeAsyncScript.js
│ │ │ │ ├── executeScript.js
│ │ │ │ ├── injectScript.js
│ │ │ │ └── source.js
│ │ │ ├── enablePerformanceMetrics.js
│ │ │ ├── end.js
│ │ │ ├── getCookie.js
│ │ │ ├── getCookies.js
│ │ │ ├── getLog.js
│ │ │ ├── getLogTypes.js
│ │ │ ├── getPerformanceMetrics.js
│ │ │ ├── getTitle.js
│ │ │ ├── getWindowPosition.js
│ │ │ ├── getWindowRect.js
│ │ │ ├── getWindowSize.js
│ │ │ ├── init.js
│ │ │ ├── injectScript.js
│ │ │ ├── isLogAvailable.js
│ │ │ ├── logs/
│ │ │ │ ├── captureBrowserConsoleLogs.js
│ │ │ │ ├── captureBrowserExceptions.js
│ │ │ │ ├── getSessionLog.js
│ │ │ │ ├── getSessionLogTypes.js
│ │ │ │ └── isSessionLogAvailable.js
│ │ │ ├── maximizeWindow.js
│ │ │ ├── network/
│ │ │ │ ├── captureRequests.js
│ │ │ │ ├── mockResponse.js
│ │ │ │ └── setConditions.js
│ │ │ ├── pageSource.js
│ │ │ ├── pause.js
│ │ │ ├── perform.js
│ │ │ ├── registerBasicAuth.js
│ │ │ ├── resizeWindow.js
│ │ │ ├── saveScreenshot.js
│ │ │ ├── saveSnapshot.js
│ │ │ ├── setCookie.js
│ │ │ ├── setDeviceDimensions.js
│ │ │ ├── setGeolocation.js
│ │ │ ├── setWindowPosition.js
│ │ │ ├── setWindowRect.js
│ │ │ ├── setWindowSize.js
│ │ │ ├── takeHeapSnapshot.js
│ │ │ ├── urlHash.js
│ │ │ ├── useCss.js
│ │ │ ├── useXpath.js
│ │ │ ├── window/
│ │ │ │ ├── close.js
│ │ │ │ ├── fullscreen.js
│ │ │ │ ├── getAllHandles.js
│ │ │ │ ├── getHandle.js
│ │ │ │ ├── getPosition.js
│ │ │ │ ├── getRect.js
│ │ │ │ ├── getSize.js
│ │ │ │ ├── maximize.js
│ │ │ │ ├── minimize.js
│ │ │ │ ├── open.js
│ │ │ │ ├── setPosition.js
│ │ │ │ ├── setRect.js
│ │ │ │ ├── setSize.js
│ │ │ │ └── switchTo.js
│ │ │ └── within.js
│ │ ├── element-commands/
│ │ │ ├── _baseElementCommand.js
│ │ │ ├── _waitFor.js
│ │ │ ├── _waitForDisplayed.js
│ │ │ ├── check.js
│ │ │ ├── clearValue.js
│ │ │ ├── click.js
│ │ │ ├── clickAndHold.js
│ │ │ ├── doubleClick.js
│ │ │ ├── dragAndDrop.js
│ │ │ ├── findElement.js
│ │ │ ├── findElements.js
│ │ │ ├── getAccessibleName.js
│ │ │ ├── getAriaRole.js
│ │ │ ├── getAttribute.js
│ │ │ ├── getCssProperty.js
│ │ │ ├── getElementProperty.js
│ │ │ ├── getElementRect.js
│ │ │ ├── getElementSize.js
│ │ │ ├── getFirstElementChild.js
│ │ │ ├── getLastElementChild.js
│ │ │ ├── getLocation.js
│ │ │ ├── getLocationInView.js
│ │ │ ├── getNextSibling.js
│ │ │ ├── getPreviousSibling.js
│ │ │ ├── getShadowRoot.js
│ │ │ ├── getTagName.js
│ │ │ ├── getText.js
│ │ │ ├── getValue.js
│ │ │ ├── hasDescendants.js
│ │ │ ├── isEnabled.js
│ │ │ ├── isPresent.js
│ │ │ ├── isSelected.js
│ │ │ ├── isVisible.js
│ │ │ ├── moveToElement.js
│ │ │ ├── rightClick.js
│ │ │ ├── sendKeys.js
│ │ │ ├── setAttribute.js
│ │ │ ├── setPassword.js
│ │ │ ├── setValue.js
│ │ │ ├── submitForm.js
│ │ │ ├── takeElementScreenshot.js
│ │ │ ├── uncheck.js
│ │ │ ├── updateValue.js
│ │ │ ├── uploadFile.js
│ │ │ ├── waitForElementNotPresent.js
│ │ │ ├── waitForElementNotVisible.js
│ │ │ ├── waitForElementPresent.js
│ │ │ └── waitForElementVisible.js
│ │ ├── expect/
│ │ │ ├── _baseExpect.js
│ │ │ ├── assertions/
│ │ │ │ ├── _baseAssertion.js
│ │ │ │ ├── element/
│ │ │ │ │ ├── _element-assertion.js
│ │ │ │ │ ├── active.js
│ │ │ │ │ ├── attribute.js
│ │ │ │ │ ├── css.js
│ │ │ │ │ ├── enabled.js
│ │ │ │ │ ├── present.js
│ │ │ │ │ ├── property.js
│ │ │ │ │ ├── selected.js
│ │ │ │ │ ├── text.js
│ │ │ │ │ ├── type.js
│ │ │ │ │ ├── value.js
│ │ │ │ │ └── visible.js
│ │ │ │ └── elements/
│ │ │ │ └── count.js
│ │ │ ├── component.js
│ │ │ ├── cookie.js
│ │ │ ├── element.js
│ │ │ ├── elements.js
│ │ │ ├── title.js
│ │ │ └── url.js
│ │ ├── index.js
│ │ ├── protocol/
│ │ │ ├── _base-action.js
│ │ │ ├── acceptAlert.js
│ │ │ ├── appium/
│ │ │ │ ├── getContext.js
│ │ │ │ ├── getContexts.js
│ │ │ │ ├── getCurrentActivity.js
│ │ │ │ ├── getCurrentPackage.js
│ │ │ │ ├── getGeolocation.js
│ │ │ │ ├── getOrientation.js
│ │ │ │ ├── hideKeyboard.js
│ │ │ │ ├── isKeyboardShown.js
│ │ │ │ ├── longPressKeyCode.js
│ │ │ │ ├── pressKeyCode.js
│ │ │ │ ├── resetApp.js
│ │ │ │ ├── setContext.js
│ │ │ │ ├── setGeolocation.js
│ │ │ │ ├── setOrientation.js
│ │ │ │ └── startActivity.js
│ │ │ ├── back.js
│ │ │ ├── closeWindow.js
│ │ │ ├── contexts.js
│ │ │ ├── cookie.js
│ │ │ ├── currentContext.js
│ │ │ ├── dismissAlert.js
│ │ │ ├── element.js
│ │ │ ├── elementActive.js
│ │ │ ├── elementIdAttribute.js
│ │ │ ├── elementIdClear.js
│ │ │ ├── elementIdClick.js
│ │ │ ├── elementIdCssProperty.js
│ │ │ ├── elementIdDisplayed.js
│ │ │ ├── elementIdDoubleClick.js
│ │ │ ├── elementIdElement.js
│ │ │ ├── elementIdElements.js
│ │ │ ├── elementIdEnabled.js
│ │ │ ├── elementIdEquals.js
│ │ │ ├── elementIdLocation.js
│ │ │ ├── elementIdLocationInView.js
│ │ │ ├── elementIdName.js
│ │ │ ├── elementIdProperty.js
│ │ │ ├── elementIdSelected.js
│ │ │ ├── elementIdSize.js
│ │ │ ├── elementIdText.js
│ │ │ ├── elementIdValue.js
│ │ │ ├── elements.js
│ │ │ ├── forward.js
│ │ │ ├── frame.js
│ │ │ ├── frameParent.js
│ │ │ ├── fullscreenWindow.js
│ │ │ ├── getAlertText.js
│ │ │ ├── getCurrentUrl.js
│ │ │ ├── getOrientation.js
│ │ │ ├── keys.js
│ │ │ ├── minimizeWindow.js
│ │ │ ├── mouseButtonClick.js
│ │ │ ├── mouseButtonDown.js
│ │ │ ├── mouseButtonUp.js
│ │ │ ├── moveTo.js
│ │ │ ├── navigateTo.js
│ │ │ ├── openNewWindow.js
│ │ │ ├── quit.js
│ │ │ ├── refresh.js
│ │ │ ├── releaseMouseButton.js
│ │ │ ├── screenshot.js
│ │ │ ├── session.js
│ │ │ ├── sessionLog.js
│ │ │ ├── sessionLogTypes.js
│ │ │ ├── sessions.js
│ │ │ ├── setAlertText.js
│ │ │ ├── setContext.js
│ │ │ ├── setOrientation.js
│ │ │ ├── source.js
│ │ │ ├── status.js
│ │ │ ├── submit.js
│ │ │ ├── switchToWindow.js
│ │ │ ├── timeouts.js
│ │ │ ├── timeoutsAsyncScript.js
│ │ │ ├── timeoutsImplicitWait.js
│ │ │ ├── title.js
│ │ │ ├── url.js
│ │ │ ├── waitUntil.js
│ │ │ ├── windowHandle.js
│ │ │ ├── windowHandles.js
│ │ │ ├── windowMaximize.js
│ │ │ ├── windowPosition.js
│ │ │ ├── windowRect.js
│ │ │ └── windowSize.js
│ │ └── web-element/
│ │ ├── assert/
│ │ │ ├── element-assertions.js
│ │ │ ├── elements-assertions.js
│ │ │ └── value-assertions.js
│ │ ├── commands/
│ │ │ ├── check.js
│ │ │ ├── clear.js
│ │ │ ├── click.js
│ │ │ ├── clickAndHold.js
│ │ │ ├── doubleClick.js
│ │ │ ├── dragAndDrop.js
│ │ │ ├── find.js
│ │ │ ├── findAll.js
│ │ │ ├── findAllByAltText.js
│ │ │ ├── findAllByPlaceholderText.js
│ │ │ ├── findAllByRole.js
│ │ │ ├── findAllByText.js
│ │ │ ├── findByAltText.js
│ │ │ ├── findByLabelText.js
│ │ │ ├── findByPlaceholderText.js
│ │ │ ├── findByRole.js
│ │ │ ├── findByText.js
│ │ │ ├── getAccessibleName.js
│ │ │ ├── getAriaRole.js
│ │ │ ├── getAttribute.js
│ │ │ ├── getCssProperty.js
│ │ │ ├── getFirstElementChild.js
│ │ │ ├── getId.js
│ │ │ ├── getLastElementChild.js
│ │ │ ├── getNextElementSibling.js
│ │ │ ├── getParentElement.js
│ │ │ ├── getPreviousElementSibling.js
│ │ │ ├── getProperty.js
│ │ │ ├── getRect.js
│ │ │ ├── getShadowRoot.js
│ │ │ ├── getTagName.js
│ │ │ ├── getText.js
│ │ │ ├── getValue.js
│ │ │ ├── inspectInDevTools.js
│ │ │ ├── isActive.js
│ │ │ ├── isEnabled.js
│ │ │ ├── isPresent.js
│ │ │ ├── isSelected.js
│ │ │ ├── isVisible.js
│ │ │ ├── moveTo.js
│ │ │ ├── rightClick.js
│ │ │ ├── sendKeys.js
│ │ │ ├── setAttribute.js
│ │ │ ├── setProperty.js
│ │ │ ├── setValue.js
│ │ │ ├── submit.js
│ │ │ ├── takeScreenshot.js
│ │ │ ├── uncheck.js
│ │ │ ├── update.js
│ │ │ └── upload.js
│ │ ├── element-locator.js
│ │ ├── element-value.js
│ │ ├── factory.js
│ │ ├── index.js
│ │ ├── scoped-element.js
│ │ ├── scoped-elements.js
│ │ └── waitUntil.js
│ ├── assertion/
│ │ ├── assertion-error.js
│ │ ├── assertion-runner.js
│ │ ├── assertion.js
│ │ └── index.js
│ ├── core/
│ │ ├── asynctree.js
│ │ ├── client.js
│ │ ├── namespaced-api.js
│ │ ├── queue.js
│ │ └── treenode.js
│ ├── element/
│ │ ├── appium-locator.js
│ │ ├── command.js
│ │ ├── index.js
│ │ ├── locate/
│ │ │ ├── elements-by-recursion.js
│ │ │ ├── recursive-lookup.js
│ │ │ └── single-element-by-recursion.js
│ │ ├── locator-factory.js
│ │ ├── locator.js
│ │ └── strategy.js
│ ├── http/
│ │ ├── auth.js
│ │ ├── formatter.js
│ │ ├── http.js
│ │ ├── options.js
│ │ ├── request.js
│ │ └── response.js
│ ├── index.js
│ ├── page-object/
│ │ ├── base-object.js
│ │ ├── command-wrapper.js
│ │ ├── index.js
│ │ └── section.js
│ ├── reporter/
│ │ ├── axe-report.js
│ │ ├── base-reporter.js
│ │ ├── global-reporter.js
│ │ ├── index.js
│ │ ├── reporters/
│ │ │ ├── html.js
│ │ │ ├── json.js
│ │ │ ├── junit.js
│ │ │ ├── junit.xml.ejs
│ │ │ └── minimalJson.js
│ │ ├── results.js
│ │ ├── simplified.js
│ │ └── summary.js
│ ├── runner/
│ │ ├── androidEmulator.js
│ │ ├── cli/
│ │ │ ├── argv-setup.js
│ │ │ ├── cli.js
│ │ │ └── nightwatch.conf.ejs
│ │ ├── concurrency/
│ │ │ ├── child-process.js
│ │ │ ├── index.js
│ │ │ ├── task.js
│ │ │ ├── worker-process.js
│ │ │ └── worker-task.js
│ │ ├── eventHub.js
│ │ ├── folder-walk.js
│ │ ├── matchers/
│ │ │ ├── filename.js
│ │ │ └── tags.js
│ │ ├── process-listener.js
│ │ ├── rerunUtil.js
│ │ ├── runner.js
│ │ ├── test-runners/
│ │ │ ├── cucumber/
│ │ │ │ ├── README.md
│ │ │ │ ├── _setup_cucumber_runner.js
│ │ │ │ └── nightwatch-format.js
│ │ │ ├── cucumber.js
│ │ │ ├── default.js
│ │ │ ├── mocha/
│ │ │ │ ├── custom-runnable.js
│ │ │ │ ├── custom-runner.js
│ │ │ │ ├── extensions.js
│ │ │ │ └── nightwatchSuite.js
│ │ │ └── mocha.js
│ │ └── test-source.js
│ ├── settings/
│ │ ├── defaults.js
│ │ └── settings.js
│ ├── testsuite/
│ │ ├── context.js
│ │ ├── globals.js
│ │ ├── hooks/
│ │ │ ├── _basehook.js
│ │ │ ├── afterAll.js
│ │ │ ├── afterChildProcess.js
│ │ │ ├── afterEach.js
│ │ │ ├── beforeAll.js
│ │ │ ├── beforeChildProcess.js
│ │ │ └── beforeEach.js
│ │ ├── hooks.js
│ │ ├── index.js
│ │ ├── interfaces/
│ │ │ ├── common.js
│ │ │ ├── describe.js
│ │ │ └── exports.js
│ │ ├── nightwatch-inspector/
│ │ │ ├── index.js
│ │ │ └── websocket-server.js
│ │ ├── repl.js
│ │ ├── retries.js
│ │ ├── runnable.js
│ │ └── testcase.js
│ ├── transport/
│ │ ├── errors/
│ │ │ └── index.js
│ │ ├── factory.js
│ │ ├── index.js
│ │ └── selenium-webdriver/
│ │ ├── actions.js
│ │ ├── appium.js
│ │ ├── appiumBase.js
│ │ ├── browserstack/
│ │ │ ├── appAutomate.js
│ │ │ ├── automate.js
│ │ │ ├── automateTurboScale.js
│ │ │ └── browserstack.js
│ │ ├── cdp.js
│ │ ├── chrome.js
│ │ ├── edge.js
│ │ ├── firefox.js
│ │ ├── httpclient.js
│ │ ├── index.js
│ │ ├── method-mappings.js
│ │ ├── options.js
│ │ ├── safari.js
│ │ ├── selenium.js
│ │ ├── service-builders/
│ │ │ ├── appium.js
│ │ │ ├── base-service.js
│ │ │ ├── chrome.js
│ │ │ ├── edge.js
│ │ │ ├── firefox.js
│ │ │ ├── safari.js
│ │ │ └── selenium.js
│ │ └── session.js
│ └── utils/
│ ├── addDetailedError.js
│ ├── alwaysDisplayError.js
│ ├── analytics.js
│ ├── beautifyStackTrace.js
│ ├── browsername.js
│ ├── chalkColors.js
│ ├── createPromise.js
│ ├── debuggability.js
│ ├── getAllClassMethodNames.js
│ ├── getFreePort.js
│ ├── index.js
│ ├── isErrorObject.js
│ ├── locatestrategy.js
│ ├── logger/
│ │ ├── index.js
│ │ └── log_settings.js
│ ├── mobile.js
│ ├── periodic-promise.js
│ ├── printVersionInfo.js
│ ├── requireModule.js
│ ├── safeStringify.js
│ ├── screenshots.js
│ ├── seleniumAtoms.js
│ ├── snapshots.js
│ ├── stackTrace.js
│ ├── timed-callback.js
│ └── version.js
├── package.json
├── test/
│ ├── .eslintrc
│ ├── apidemos/
│ │ ├── actions-api/
│ │ │ ├── actionsApi.js
│ │ │ └── asyncActionsApi.js
│ │ ├── angular-test/
│ │ │ ├── angularTodoListWithClassicApis.js
│ │ │ ├── angularTodoListWithElementGlobal.js
│ │ │ ├── angularTodoListWithElementGlobalAndError.js
│ │ │ └── angularTodoListWithElementGlobalAsync.js
│ │ ├── appium/
│ │ │ └── appiumTest.js
│ │ ├── cdp/
│ │ │ ├── registerAuth.js
│ │ │ └── registerAuth2.js
│ │ ├── chrome/
│ │ │ └── chromeTest.js
│ │ ├── cookies/
│ │ │ ├── cookieTests.js
│ │ │ └── cookieTestsWithError.js
│ │ ├── custom-commands/
│ │ │ ├── testNamespacedAliases.js
│ │ │ ├── testUsingAsyncCustomAssert.js
│ │ │ ├── testUsingAutoInvokeCommand.js
│ │ │ ├── testUsingCommandReturnFn.js
│ │ │ ├── testUsingCustomExecute.js
│ │ │ ├── testUsingCustomGetEmail.js
│ │ │ └── testUsingES6AsyncCustomCommands.js
│ │ ├── custom-commands-parallel/
│ │ │ └── testUsingES6AsyncCustomCommands.js
│ │ ├── elements/
│ │ │ ├── elementGlobalTest.js
│ │ │ ├── findElementsCustomCommand.js
│ │ │ ├── findElementsPageCommands.js
│ │ │ └── testGlobalLocateStrategy.js
│ │ ├── ensure/
│ │ │ ├── ensureTestError.js
│ │ │ ├── ensureTestNotSelected.js
│ │ │ └── ensureTestSelected.js
│ │ ├── expect-global/
│ │ │ ├── deepEqual.js
│ │ │ └── expect.js
│ │ ├── firefox/
│ │ │ └── firefoxTest.js
│ │ ├── namespaced-api/
│ │ │ └── namespacedApiTest.js
│ │ ├── navigation/
│ │ │ └── navigateTest.js
│ │ ├── page-objects/
│ │ │ └── commandsReturnTypeTest.js
│ │ ├── relative-locators/
│ │ │ └── sample-with-relative-locators.js
│ │ └── web-elements/
│ │ ├── assertionTest.js
│ │ ├── elementApiWithPageObjects.js
│ │ ├── waitUntilElementNotPresent.js
│ │ ├── waitUntilFailureTest.js
│ │ └── waitUntilTest.js
│ ├── asynchookstests/
│ │ ├── afterEach-timeout/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── async-provide-error/
│ │ │ ├── after.js
│ │ │ ├── afterAsync.js
│ │ │ ├── afterEach.js
│ │ │ ├── afterEachAsync.js
│ │ │ ├── afterEachWithClient.js
│ │ │ ├── afterWithClient.js
│ │ │ ├── before.js
│ │ │ ├── beforeAsync.js
│ │ │ ├── beforeEach.js
│ │ │ ├── beforeEachAsync.js
│ │ │ ├── beforeEachAsyncWithClient.js
│ │ │ ├── beforeEachAsyncWithClientMultiple.js
│ │ │ ├── beforeEachWithClient.js
│ │ │ └── beforeWithClient.js
│ │ ├── before-timeout/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── sampleWithAssertionFailedInAfter.js
│ │ ├── sampleWithAssertionFailedInBefore.js
│ │ ├── sampleWithErrorInTestcaseAndAfter.js
│ │ ├── sampleWithFailureInBeforeAndAfter.js
│ │ ├── sampleWithFailureInTestcaseAndAfter.js
│ │ ├── unittest-async-timeout.js
│ │ ├── unittest-error.js
│ │ └── unittest-failure/
│ │ └── unittest-failure.js
│ ├── common.js
│ ├── component-tests/
│ │ ├── samples/
│ │ │ ├── nightwatch.conf-noplugins.js
│ │ │ ├── react/
│ │ │ │ ├── nightwatch.conf.js
│ │ │ │ ├── src/
│ │ │ │ │ └── Form.jsx
│ │ │ │ └── tests/
│ │ │ │ ├── Form.spec--_with-$hooks.jsx
│ │ │ │ ├── formTest--notFound.js
│ │ │ │ └── formTest.js
│ │ │ └── vue/
│ │ │ ├── nightwatch.conf.js
│ │ │ ├── src/
│ │ │ │ └── Form.vue
│ │ │ └── tests/
│ │ │ ├── formTest--notFound.js
│ │ │ └── formTest.js
│ │ └── src/
│ │ ├── testRunBasicReact.js
│ │ ├── testRunBasicVue.js
│ │ └── testRunnJSXReact.js
│ ├── cucumber-integration-tests/
│ │ ├── sample_cucumber_tests/
│ │ │ ├── chainingCommands/
│ │ │ │ └── testCommands.js
│ │ │ ├── customCommands/
│ │ │ │ └── testCucumberWithCustomWait.js
│ │ │ ├── integration/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallel/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallel-formatters/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallelWithMultipleDefinition/
│ │ │ │ ├── testExpect.js
│ │ │ │ └── testSample.js
│ │ │ ├── with-extra-setup/
│ │ │ │ ├── _extra_setup.js
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── with-modified-settings/
│ │ │ │ ├── plugin/
│ │ │ │ │ ├── index.js
│ │ │ │ │ └── nightwatch/
│ │ │ │ │ └── globals.js
│ │ │ │ └── testSample.js
│ │ │ ├── withexpect/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ └── withwaitFor/
│ │ │ ├── sample.feature
│ │ │ └── testWithFailures.js
│ │ ├── testCucumberTestsInParallel.js
│ │ ├── testCucumberTestsParallelFormatters.js
│ │ ├── testCucumberTestsWithExpect.js
│ │ ├── testCucumberTestsWithExtras.js
│ │ ├── testCucumberTestsWithModifiedSettings.js
│ │ └── testCucumberTestsWithWaitFor.js
│ ├── extra/
│ │ ├── assertions/
│ │ │ ├── .dotrc
│ │ │ ├── customAssertion.js
│ │ │ └── customAssertionWithSelector.js
│ │ ├── commands/
│ │ │ ├── _otherPerform.js
│ │ │ ├── autoInvoke/
│ │ │ │ └── customCommandInvoke.js
│ │ │ ├── customClearValue.js
│ │ │ ├── customCommand.js
│ │ │ ├── customCommandAppendResults.js
│ │ │ ├── customCommandConstructor.js
│ │ │ ├── customCommandWithFailure.js
│ │ │ ├── customCommandWithFailureClass.js
│ │ │ ├── customCommandWithSelector.js
│ │ │ ├── customElementPresent.js
│ │ │ ├── customExecute.js
│ │ │ ├── customPauseWithNamespacedAlias.js
│ │ │ ├── customPerform.js
│ │ │ ├── customQuit.js
│ │ │ ├── customWaitForPresent.js
│ │ │ ├── es6async/
│ │ │ │ ├── basicPerform.js
│ │ │ │ ├── basicPerformWithFluentApi.js
│ │ │ │ ├── customExecuteAsync.js
│ │ │ │ ├── customFindElements.js
│ │ │ │ ├── customFindElementsES6.js
│ │ │ │ ├── customPerform.js
│ │ │ │ ├── customPerformClass.js
│ │ │ │ ├── customVisible.js
│ │ │ │ └── getEmail.js
│ │ │ ├── other/
│ │ │ │ └── otherCommand.js
│ │ │ ├── returnFn/
│ │ │ │ └── customCommandReturnFn.js
│ │ │ └── typescript/
│ │ │ ├── tsWait.js
│ │ │ └── tsWait.ts
│ │ ├── cucumber-config-events.js
│ │ ├── cucumber-config-expect.js
│ │ ├── cucumber-config-noautostart.js
│ │ ├── cucumber-config-parallel-formatters.js
│ │ ├── cucumber-config-parallel.js
│ │ ├── cucumber-config-waitFor.js
│ │ ├── cucumber-config.js
│ │ ├── existing-custom-commands/
│ │ │ └── click.js
│ │ ├── external-globals-async.js
│ │ ├── external-globals.js
│ │ ├── globals-err.js
│ │ ├── globals.js
│ │ ├── minimalJsonReporter.json
│ │ ├── mock-errors/
│ │ │ └── sample-error.js
│ │ ├── nightwatch.json
│ │ ├── otherPageobjects/
│ │ │ └── otherPage.js
│ │ ├── package.json
│ │ ├── pageobjects/
│ │ │ ├── commands/
│ │ │ │ ├── commandsClassWithName.js
│ │ │ │ ├── common-commands.js
│ │ │ │ ├── helperCommandsClass.js
│ │ │ │ └── workingCommandsClass.js
│ │ │ └── pages/
│ │ │ ├── addl/
│ │ │ │ └── simplePageObject.js
│ │ │ ├── api/
│ │ │ │ └── method/
│ │ │ │ ├── bar.js
│ │ │ │ └── foo.js
│ │ │ ├── invalidPageObj.js
│ │ │ ├── pageObjElementsArray.js
│ │ │ ├── simplePageObj.js
│ │ │ ├── simplePageObjDefaultXpath.js
│ │ │ ├── simplePageObjWithCommandsClass.js
│ │ │ ├── simplePageObjWithCommandsClassThrowsError.js
│ │ │ ├── simplePageObjWithCommandsObject.js
│ │ │ ├── simplePageObjWithError.js
│ │ │ ├── waitForElementNotPresentPageObj.js
│ │ │ └── workingPageObjPlain.js
│ │ ├── parallelism-auto.json
│ │ ├── parallelism-count.json
│ │ ├── parallelism-customCommandsSync.json
│ │ ├── parallelism-disabled.json
│ │ ├── parallelism-envs.json
│ │ ├── parallelism-execArgv-selected.json
│ │ ├── parallelism-execArgv.json
│ │ ├── parallelism-selenium-server.json
│ │ ├── parallelism-workers.conf.js
│ │ ├── parallelism.json
│ │ ├── plugin/
│ │ │ ├── index.js
│ │ │ └── nightwatch/
│ │ │ ├── assertions/
│ │ │ │ └── customAssertion.js
│ │ │ ├── commands/
│ │ │ │ └── customCommand.js
│ │ │ └── globals.js
│ │ ├── reportObject.js
│ │ ├── reporter/
│ │ │ ├── custom.js
│ │ │ └── notvalid.js
│ │ ├── withgeckodriver-concurrent.json
│ │ ├── withmocha.json
│ │ └── withsafari-concurrent.json
│ ├── lib/
│ │ ├── command-mocks.js
│ │ ├── fakedriver.js
│ │ ├── globals/
│ │ │ ├── commands-w3c.js
│ │ │ ├── commands.js
│ │ │ └── expect.js
│ │ ├── globals.js
│ │ ├── mochatest.js
│ │ ├── mockclient.js
│ │ ├── mocks/
│ │ │ ├── api-loader/
│ │ │ │ ├── assertion-loader.js
│ │ │ │ └── assertion.js
│ │ │ ├── assertionLoader.js
│ │ │ ├── core/
│ │ │ │ ├── assertion.js
│ │ │ │ └── session.js
│ │ │ ├── mocks-jsonwire.yaml
│ │ │ └── mocks-w3c.yaml
│ │ ├── mocks.json
│ │ ├── mockserver.js
│ │ ├── nightwatch.js
│ │ ├── nocks.js
│ │ ├── nockselements.js
│ │ └── utils.js
│ ├── mocha.opts
│ ├── mochatests/
│ │ ├── async/
│ │ │ ├── sampleWithAsyncWithFailures.js
│ │ │ └── sampleWithBeforeAndAfter.js
│ │ └── integration/
│ │ ├── sampleWithAsyncTestcase.js
│ │ ├── sampleWithBeforeAndAfter.js
│ │ └── sampleWithFailures.js
│ ├── nightwatch.json
│ ├── sampletests/
│ │ ├── appendtestresult/
│ │ │ └── sampleWithAppendResults.js
│ │ ├── async/
│ │ │ └── test/
│ │ │ └── sample.js
│ │ ├── asyncwithexpectfailures/
│ │ │ └── sample.js
│ │ ├── asyncwithfailures/
│ │ │ ├── sampleWithAsyncWithFailures.js
│ │ │ ├── sampleWithAsyncWithSingleTestFailure.js
│ │ │ └── sampleWithBeforeAndAfter.js
│ │ ├── before-after/
│ │ │ ├── sampleSingleTest.js
│ │ │ ├── sampleWithBeforeAndAfter.js
│ │ │ ├── sampleWithBeforeAndAfterNoCallback.js
│ │ │ └── syncBeforeAndAfter.js
│ │ ├── beforewithcommand/
│ │ │ ├── commandInsideBefore.js
│ │ │ └── commandInsideBeforeWithNoParams.js
│ │ ├── empty/
│ │ │ └── .gitignore
│ │ ├── es6await/
│ │ │ ├── basicSampleTest.js
│ │ │ ├── incorrect-element-args/
│ │ │ │ └── sampleTestProperty.js
│ │ │ ├── selenium/
│ │ │ │ ├── basicSampleTestSelenium.js
│ │ │ │ ├── failures/
│ │ │ │ │ └── sampleWithFailures.js
│ │ │ │ └── getlog/
│ │ │ │ └── getLogTestES6.js
│ │ │ └── webdriver/
│ │ │ └── getText/
│ │ │ └── getTextES6.js
│ │ ├── isPresent/
│ │ │ └── elementNotPresent.js
│ │ ├── mixed/
│ │ │ └── sample.js
│ │ ├── mixed-files/
│ │ │ ├── sampleJs.js
│ │ │ └── sampleTs.ts
│ │ ├── passwordValueRedacted/
│ │ │ └── passwordValueRedacted.js
│ │ ├── reusebrowser/
│ │ │ ├── firstTest.js
│ │ │ └── secondTest.js
│ │ ├── sampleforreport/
│ │ │ ├── sample.js
│ │ │ └── sampleWithFailure.js
│ │ ├── simple/
│ │ │ └── test/
│ │ │ └── sample.js
│ │ ├── srcfolders/
│ │ │ └── other_sample.js
│ │ ├── suiteretries/
│ │ │ ├── locate-strategy/
│ │ │ │ └── suiteRetriesLocateStrategy.js
│ │ │ └── sample/
│ │ │ └── suiteRetriesSample.js
│ │ ├── syncnames/
│ │ │ └── sampleTest.js
│ │ ├── tags/
│ │ │ └── sample.js
│ │ ├── tagswithbrowserobject/
│ │ │ └── sample.js
│ │ ├── trace/
│ │ │ └── sample.js
│ │ ├── typescript/
│ │ │ └── sample.ts
│ │ ├── unittests/
│ │ │ ├── sample.js
│ │ │ └── sampleAnnotation.js
│ │ ├── unknown-method/
│ │ │ └── UnknownMethod.js
│ │ ├── usexpath/
│ │ │ └── sample.js
│ │ ├── usingwithin/
│ │ │ ├── testNoWithin.js
│ │ │ └── testWithin.js
│ │ ├── webelement/
│ │ │ └── findWithSuppressNotFoundErrors.js
│ │ ├── withaftereach/
│ │ │ └── sampleSingleTest.js
│ │ ├── withasynchooks/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── withchaiexpect/
│ │ │ ├── sampleWithChai.js
│ │ │ └── sampleWithGlobalExpect.js
│ │ ├── withcommanderrors/
│ │ │ └── demoTest.js
│ │ ├── withcustomcommands/
│ │ │ ├── element/
│ │ │ │ └── withCustomElementCommand.js
│ │ │ ├── sampleWithAsyncFailures.js
│ │ │ └── sampleWithFailures.js
│ │ ├── withdescribe/
│ │ │ ├── basic/
│ │ │ │ ├── sample.js
│ │ │ │ └── sampleWithOnly.js
│ │ │ ├── basic2/
│ │ │ │ └── sample.js
│ │ │ ├── failures/
│ │ │ │ ├── sampleSkipTestcases.js
│ │ │ │ ├── sampleTest.js
│ │ │ │ └── sampleTestWithAttribute.js
│ │ │ ├── skipped/
│ │ │ │ ├── duplicateTestcases.js
│ │ │ │ ├── skipBeforeAfterEach.js
│ │ │ │ ├── skipTestcase.js
│ │ │ │ └── skipTestsuite.js
│ │ │ ├── suite-retries/
│ │ │ │ ├── sample.js
│ │ │ │ └── sampleWithAttribute.js
│ │ │ └── unittests/
│ │ │ └── sampleAnnotationWithDescribe.js
│ │ ├── withelementerrors/
│ │ │ └── sampleTestWithElementError.js
│ │ ├── witherrors/
│ │ │ └── sampleWithError.js
│ │ ├── withes6asynccommands/
│ │ │ └── sampleWithAsyncCommands.js
│ │ ├── withexclude/
│ │ │ ├── excluded/
│ │ │ │ ├── excluded-module.js
│ │ │ │ └── not-excluded.js
│ │ │ └── simple/
│ │ │ └── sample.js
│ │ ├── withfailures/
│ │ │ └── sample.js
│ │ ├── withpageobjects/
│ │ │ └── useXpathWithPageObjects.js
│ │ ├── withservererrors/
│ │ │ └── sampleTestWithServerError.js
│ │ ├── withsubfolders/
│ │ │ ├── simple/
│ │ │ │ └── sample.js
│ │ │ └── tags/
│ │ │ └── sampleTags.js
│ │ ├── withuknownRequire/
│ │ │ └── sample.js
│ │ ├── withuncaughterrors/
│ │ │ ├── demoTestFine.js
│ │ │ └── demoTestWithError.js
│ │ ├── withverify/
│ │ │ ├── verifySampleFailures.js
│ │ │ └── verifyWithinPerform.js
│ │ ├── withwait/
│ │ │ └── elementNotPresent.js
│ │ └── withwebdriver/
│ │ └── sampleTestUsingSeleniumWebdriver.js
│ ├── src/
│ │ ├── analytics/
│ │ │ └── testAnalytics.js
│ │ ├── api/
│ │ │ ├── assertions/
│ │ │ │ ├── testAttributeContains.js
│ │ │ │ ├── testAttributeEquals.js
│ │ │ │ ├── testAttributeMatches.js
│ │ │ │ ├── testContainsText.js
│ │ │ │ ├── testCssClassPresent.js
│ │ │ │ ├── testCssProperty.js
│ │ │ │ ├── testDomPropertyContains.js
│ │ │ │ ├── testDomPropertyEquals.js
│ │ │ │ ├── testDomPropertyMatches.js
│ │ │ │ ├── testElementPresent.js
│ │ │ │ ├── testElementsCount.js
│ │ │ │ ├── testEnabled.js
│ │ │ │ ├── testHasAttribute.js
│ │ │ │ ├── testHasClass.js
│ │ │ │ ├── testHidden.js
│ │ │ │ ├── testSelected.js
│ │ │ │ ├── testTextEquals.js
│ │ │ │ ├── testTextMatches.js
│ │ │ │ ├── testTitle.js
│ │ │ │ ├── testTitleContains.js
│ │ │ │ ├── testTitleEquals.js
│ │ │ │ ├── testTitleMatches.js
│ │ │ │ ├── testUrlContains.js
│ │ │ │ ├── testUrlEquals.js
│ │ │ │ ├── testUrlMatches.js
│ │ │ │ ├── testValue.js
│ │ │ │ ├── testValueContains.js
│ │ │ │ ├── testValueEquals.js
│ │ │ │ └── testVisible.js
│ │ │ ├── commands/
│ │ │ │ ├── client/
│ │ │ │ │ ├── testAxeCommands.js
│ │ │ │ │ ├── testCaptureNetworkRequests.js
│ │ │ │ │ ├── testEnablePerformanceMetrics.js
│ │ │ │ │ ├── testEnd.js
│ │ │ │ │ ├── testGetPerformanceMetrics.js
│ │ │ │ │ ├── testInit.js
│ │ │ │ │ ├── testLocateStrategy.js
│ │ │ │ │ ├── testMockNetworkResponse.js
│ │ │ │ │ ├── testNavigateTo.js
│ │ │ │ │ ├── testNightwatchRepl.js
│ │ │ │ │ ├── testPause.js
│ │ │ │ │ ├── testPerform.js
│ │ │ │ │ ├── testRegisterBasicAuth.js
│ │ │ │ │ ├── testSaveScreenshot.js
│ │ │ │ │ ├── testSaveSnapshot.js
│ │ │ │ │ ├── testSetDeviceDimensions.js
│ │ │ │ │ ├── testSetGeolocation.js
│ │ │ │ │ ├── testSetNetworkConditions.js
│ │ │ │ │ ├── testTakeHeapSnapshot.js
│ │ │ │ │ └── testWaitUntil.js
│ │ │ │ ├── cookies/
│ │ │ │ │ ├── testCookie.js
│ │ │ │ │ ├── testCookies.js
│ │ │ │ │ └── testCookiesErrors.js
│ │ │ │ ├── document/
│ │ │ │ │ ├── testExecute.js
│ │ │ │ │ ├── testInjectScript.js
│ │ │ │ │ └── testSource.js
│ │ │ │ ├── element/
│ │ │ │ │ ├── testCheck.js
│ │ │ │ │ ├── testClearValue.js
│ │ │ │ │ ├── testClick.js
│ │ │ │ │ ├── testClickAndHold.js
│ │ │ │ │ ├── testClickMobile.js
│ │ │ │ │ ├── testDoubleClick.js
│ │ │ │ │ ├── testDragAndDrop.js
│ │ │ │ │ ├── testGetAccessibleName.js
│ │ │ │ │ ├── testGetAriaRole.js
│ │ │ │ │ ├── testGetAttribute.js
│ │ │ │ │ ├── testGetAttributeW3c.js
│ │ │ │ │ ├── testGetCssProperty.js
│ │ │ │ │ ├── testGetElementProperty.js
│ │ │ │ │ ├── testGetElementRect.js
│ │ │ │ │ ├── testGetElementSize.js
│ │ │ │ │ ├── testGetFirstElementChild.js
│ │ │ │ │ ├── testGetLastElementChild.js
│ │ │ │ │ ├── testGetLocation.js
│ │ │ │ │ ├── testGetLocationInView.js
│ │ │ │ │ ├── testGetNextSibling.js
│ │ │ │ │ ├── testGetPreviousSibling.js
│ │ │ │ │ ├── testGetTagName.js
│ │ │ │ │ ├── testGetText.js
│ │ │ │ │ ├── testGetTitle.js
│ │ │ │ │ ├── testGetValue.js
│ │ │ │ │ ├── testHasDescendants.js
│ │ │ │ │ ├── testIsEnabled.js
│ │ │ │ │ ├── testIsPresent.js
│ │ │ │ │ ├── testIsSelected.js
│ │ │ │ │ ├── testIsVisible.js
│ │ │ │ │ ├── testMoveToElement.js
│ │ │ │ │ ├── testRightClick.js
│ │ │ │ │ ├── testSendKeys.js
│ │ │ │ │ ├── testSetAttribute.js
│ │ │ │ │ ├── testSetPassword.js
│ │ │ │ │ ├── testSetPasswordReport.js
│ │ │ │ │ ├── testSetValue.js
│ │ │ │ │ ├── testSubmitForm.js
│ │ │ │ │ ├── testTakeElementScreenshot.js
│ │ │ │ │ ├── testUncheck.js
│ │ │ │ │ ├── testUploadFile.js
│ │ │ │ │ ├── testWaitForElementNotPresent.js
│ │ │ │ │ ├── testWaitForElementNotVisible.js
│ │ │ │ │ ├── testWaitForElementPresent.js
│ │ │ │ │ └── testWaitForElementVisible.js
│ │ │ │ ├── logs/
│ │ │ │ │ ├── testCaptureBrowserConsoleLogs.js
│ │ │ │ │ ├── testCaptureBrowserExceptions.js
│ │ │ │ │ ├── testGetLog.js
│ │ │ │ │ ├── testGetLogTypes.js
│ │ │ │ │ └── testIsLogAvailable.js
│ │ │ │ ├── testPageSource.js
│ │ │ │ ├── testSendKeys.js
│ │ │ │ ├── testUpdateValue.js
│ │ │ │ ├── web-element/
│ │ │ │ │ ├── assert/
│ │ │ │ │ │ └── testElementAssertions.js
│ │ │ │ │ ├── testCheck.js
│ │ │ │ │ ├── testClear.js
│ │ │ │ │ ├── testClick.js
│ │ │ │ │ ├── testClickAndHold.js
│ │ │ │ │ ├── testDoubleClick.js
│ │ │ │ │ ├── testDragAndDrop.js
│ │ │ │ │ ├── testElement.js
│ │ │ │ │ ├── testFind.js
│ │ │ │ │ ├── testFindAll.js
│ │ │ │ │ ├── testFindAllByAltText.js
│ │ │ │ │ ├── testFindAllByPlaceholderText.js
│ │ │ │ │ ├── testFindAllByRole.js
│ │ │ │ │ ├── testFindAllByText.js
│ │ │ │ │ ├── testFindByAltText.js
│ │ │ │ │ ├── testFindByLabelText.js
│ │ │ │ │ ├── testFindByPlaceholderText.js
│ │ │ │ │ ├── testFindByRole.js
│ │ │ │ │ ├── testFindByText.js
│ │ │ │ │ ├── testFindOnErrors.js
│ │ │ │ │ ├── testGetAccessibleName.js
│ │ │ │ │ ├── testGetAriaRole.js
│ │ │ │ │ ├── testGetAttribute.js
│ │ │ │ │ ├── testGetCssProperty.js
│ │ │ │ │ ├── testGetFirstElementChild.js
│ │ │ │ │ ├── testGetId.js
│ │ │ │ │ ├── testGetLastElementChild.js
│ │ │ │ │ ├── testGetNextElementSibling.js
│ │ │ │ │ ├── testGetPreviousElementSibling.js
│ │ │ │ │ ├── testGetProperty.js
│ │ │ │ │ ├── testGetRect.js
│ │ │ │ │ ├── testGetShadowRoot.js
│ │ │ │ │ ├── testGetTagName.js
│ │ │ │ │ ├── testGetText.js
│ │ │ │ │ ├── testGetValue.js
│ │ │ │ │ ├── testIsActive.js
│ │ │ │ │ ├── testIsEnabled.js
│ │ │ │ │ ├── testIsPresent.js
│ │ │ │ │ ├── testIsSelected.js
│ │ │ │ │ ├── testIsVisible.js
│ │ │ │ │ ├── testMoveTo.js
│ │ │ │ │ ├── testRightClick.js
│ │ │ │ │ ├── testSendKeys.js
│ │ │ │ │ ├── testSetAttribute.js
│ │ │ │ │ ├── testSetProperty.js
│ │ │ │ │ ├── testSetValue.js
│ │ │ │ │ ├── testShadowFind.js
│ │ │ │ │ ├── testShadowFindAll.js
│ │ │ │ │ ├── testSubmit.js
│ │ │ │ │ ├── testTakeScreenshot.js
│ │ │ │ │ ├── testUncheck.js
│ │ │ │ │ ├── testUpdate.js
│ │ │ │ │ └── testUpload.js
│ │ │ │ └── window/
│ │ │ │ ├── testCloseWindow.js
│ │ │ │ ├── testMaximizeWindow.js
│ │ │ │ ├── testWindowCommands.js
│ │ │ │ ├── testWindowCommandsW3C.js
│ │ │ │ └── testWindowNamespaceCommands.js
│ │ │ ├── expect/
│ │ │ │ ├── testExpectActive.js
│ │ │ │ ├── testExpectAttribute.js
│ │ │ │ ├── testExpectCookie.js
│ │ │ │ ├── testExpectCount.js
│ │ │ │ ├── testExpectCss.js
│ │ │ │ ├── testExpectEnabled.js
│ │ │ │ ├── testExpectPresent.js
│ │ │ │ ├── testExpectProperty.js
│ │ │ │ ├── testExpectSelected.js
│ │ │ │ ├── testExpectText.js
│ │ │ │ ├── testExpectTitle.js
│ │ │ │ ├── testExpectType.js
│ │ │ │ ├── testExpectUrl.js
│ │ │ │ ├── testExpectValue.js
│ │ │ │ └── testExpectVisible.js
│ │ │ ├── expect-global/
│ │ │ │ ├── testElementAttribute.js
│ │ │ │ ├── testElementCss.js
│ │ │ │ ├── testElementIsDisplayed.js
│ │ │ │ ├── testElementIsEnabled.js
│ │ │ │ ├── testElementIsSelected.js
│ │ │ │ ├── testElementProperty.js
│ │ │ │ └── testElementText.js
│ │ │ └── protocol/
│ │ │ ├── testActivity.js
│ │ │ ├── testAlerts.js
│ │ │ ├── testBrowserCommands.js
│ │ │ ├── testChrome.js
│ │ │ ├── testContext.js
│ │ │ ├── testCookies.js
│ │ │ ├── testDoubleClick.js
│ │ │ ├── testElementCommands.js
│ │ │ ├── testEnsure.js
│ │ │ ├── testFirefox.js
│ │ │ ├── testFrame.js
│ │ │ ├── testFrameCommand.js
│ │ │ ├── testGeolocation.js
│ │ │ ├── testKeyboardInteraction.js
│ │ │ ├── testKeys.js
│ │ │ ├── testLog.js
│ │ │ ├── testMouseButtonClick.js
│ │ │ ├── testMoveTo.js
│ │ │ ├── testOrientation.js
│ │ │ ├── testReleaseMouseButton.js
│ │ │ ├── testResetApp.js
│ │ │ ├── testScreenshot.js
│ │ │ ├── testSendKeys.js
│ │ │ ├── testSession.js
│ │ │ ├── testSetValue.js
│ │ │ ├── testSource.js
│ │ │ ├── testStatus.js
│ │ │ ├── testSubmit.js
│ │ │ ├── testTimeouts.js
│ │ │ ├── testTitle.js
│ │ │ ├── testUploadFile.js
│ │ │ ├── testUrl.js
│ │ │ ├── testWindowCommands.js
│ │ │ ├── testWindowPosition.js
│ │ │ ├── testWindowRect.js
│ │ │ └── testWindowSize.js
│ │ ├── apidemos/
│ │ │ ├── actions-api/
│ │ │ │ ├── asyncPerformActionsTest.js
│ │ │ │ └── performActionsTest.js
│ │ │ ├── angular-test/
│ │ │ │ └── runAngularDemo.js
│ │ │ ├── appium/
│ │ │ │ └── testAppiumAPI.js
│ │ │ ├── cdp/
│ │ │ │ └── testCdpCommands.js
│ │ │ ├── chrome/
│ │ │ │ └── testChromeAPI.js
│ │ │ ├── cookies/
│ │ │ │ └── testCookieCommands.js
│ │ │ ├── custom-commands/
│ │ │ │ ├── testCustomCommandAutoInvoke.js
│ │ │ │ ├── testCustomCommandSync.js
│ │ │ │ ├── testCustomCommandsAsync.js
│ │ │ │ ├── testCustomExecuteAsync.js
│ │ │ │ └── testCustomPauseWithNamespacedAlias.js
│ │ │ ├── elements/
│ │ │ │ ├── testElementGlobal.js
│ │ │ │ ├── testFindElementsEs6CustomCommand.js
│ │ │ │ └── testFindElementsWithPageCommand.js
│ │ │ ├── ensure/
│ │ │ │ └── testEnsure.js
│ │ │ ├── expect-global/
│ │ │ │ └── testExpect.js
│ │ │ ├── firefox/
│ │ │ │ └── testFirefoxAPI.js
│ │ │ ├── namespaced-api/
│ │ │ │ └── testNamespacedApi.js
│ │ │ ├── navigation/
│ │ │ │ └── testNavigationCommands.js
│ │ │ ├── page-objects/
│ │ │ │ └── testCommandsReturnType.js
│ │ │ ├── relative-locators/
│ │ │ │ └── testWithRelativeLocators.js
│ │ │ └── web-elements/
│ │ │ ├── testAssert.js
│ │ │ ├── testElementApiWithPageObjects.js
│ │ │ └── testWaitUntil.js
│ │ ├── cli/
│ │ │ ├── testCliRunner.js
│ │ │ ├── testCliRunnerGenerate.js
│ │ │ ├── testCliRunnerMocha.js
│ │ │ ├── testDemoTypescriptFile.js
│ │ │ ├── testParallelExecution.js
│ │ │ ├── testParallelExecutionExitCode.js
│ │ │ └── testServiceCreationFromCli.js
│ │ ├── core/
│ │ │ ├── testAsyncTree.js
│ │ │ ├── testCreateSession.js
│ │ │ ├── testPageObjectApi.js
│ │ │ ├── testPageObjectCommands.js
│ │ │ ├── testPageObjectCustomCommands.js
│ │ │ ├── testPageObjectWaitForElementNotPresent.js
│ │ │ ├── testPlugins.js
│ │ │ ├── testQueue.js
│ │ │ ├── testRequestWithCredentials.js
│ │ │ └── testTreeNode.js
│ │ ├── element/
│ │ │ ├── testCommandsElementSelectors.js
│ │ │ ├── testElementCommands.js
│ │ │ ├── testExpectElementSelectors.js
│ │ │ ├── testIndexedElementSelectors.js
│ │ │ ├── testPageObjectElementSelectors-use_xpath.js
│ │ │ ├── testPageObjectElementSelectors.js
│ │ │ └── testProtocolElementSelectors.js
│ │ ├── globals.js
│ │ ├── index/
│ │ │ ├── testDefaultPathPrefixOption.js
│ │ │ ├── testMobileComponent.js
│ │ │ ├── testNightwatchIndex.js
│ │ │ ├── testProgrammaticApis.js
│ │ │ ├── testRequest.js
│ │ │ ├── testRequestTimeout.js
│ │ │ ├── testRunProtocolAction.js
│ │ │ ├── testSettings.js
│ │ │ └── transport/
│ │ │ ├── testAppiumTransport.js
│ │ │ ├── testBrowserstackTransport.js
│ │ │ ├── testChromeOptions.js
│ │ │ ├── testCreateTransport.js
│ │ │ ├── testEdgeOptions.js
│ │ │ ├── testFirefoxOptions.js
│ │ │ ├── testIeOptions.js
│ │ │ ├── testMobileOptions.js
│ │ │ ├── testMobileWebSupport.js
│ │ │ ├── testSafariOptions.js
│ │ │ └── testSeleniumTransport.js
│ │ ├── runner/
│ │ │ ├── cli/
│ │ │ │ └── testCliRunnerParallel.js
│ │ │ ├── cucumber-integration/
│ │ │ │ ├── testCliArgs.js
│ │ │ │ ├── testCucumberSampleTests.js
│ │ │ │ └── testCucumberWithBrowserstack.js
│ │ │ ├── mocha/
│ │ │ │ ├── testMochaRunnerAsync.js
│ │ │ │ └── testMochaRunnerIntegration.js
│ │ │ ├── testEventReporter.js
│ │ │ ├── testInspectorExtension.js
│ │ │ ├── testReporter.js
│ │ │ ├── testRerunFunctionality.js
│ │ │ ├── testRunBrowserstackTransport.js
│ │ │ ├── testRunTestcase.js
│ │ │ ├── testRunTestsuite.js
│ │ │ ├── testRunTestsuiteWithSuiteRetries.js
│ │ │ ├── testRunWithCommandErrors.js
│ │ │ ├── testRunWithCustomCommands.js
│ │ │ ├── testRunWithExclude.js
│ │ │ ├── testRunWithExistingCommands.js
│ │ │ ├── testRunWithExternalGlobals.js
│ │ │ ├── testRunWithGlobalHooks.js
│ │ │ ├── testRunWithGlobalReporter.js
│ │ │ ├── testRunWithHooks.js
│ │ │ ├── testRunWithMultipleSources.js
│ │ │ ├── testRunWithServerErrors.js
│ │ │ ├── testRunWithTags.js
│ │ │ ├── testRunWithVerify.js
│ │ │ ├── testRunner.js
│ │ │ ├── testRunnerChaiExpect.js
│ │ │ ├── testRunnerEndSessionOnFail.js
│ │ │ ├── testRunnerEs6Async.js
│ │ │ ├── testRunnerHtmlOutput.js
│ │ │ ├── testRunnerJsonOutput.js
│ │ │ ├── testRunnerJunitOutput.js
│ │ │ ├── testRunnerMixedFiles.js
│ │ │ ├── testRunnerRerunJsonOutput.js
│ │ │ ├── testRunnerScreenshotsOutput.js
│ │ │ ├── testRunnerSessionCreate.js
│ │ │ ├── testRunnerTypeScript.js
│ │ │ ├── testRunnerUncaughtErrors.js
│ │ │ ├── testRunnerUnitTests.js
│ │ │ ├── testRunnerUsingWithin.js
│ │ │ ├── testRunnerWithAsyncAssertionFailure.js
│ │ │ ├── testRunnerWithPageObjects.js
│ │ │ ├── testRunnerWithTrace.js
│ │ │ └── testTagsMatcher.js
│ │ ├── service-builders/
│ │ │ ├── testAppiumServer.js
│ │ │ ├── testChromeDriver.js
│ │ │ ├── testEdgeDriver.js
│ │ │ ├── testFirefoxDriver.js
│ │ │ ├── testSafariDriver.js
│ │ │ └── testSeleniumServer.js
│ │ └── utils/
│ │ ├── __data__/
│ │ │ ├── meaning-of-life.js
│ │ │ ├── meaning-of-life.mjs
│ │ │ ├── mixed-exports.mjs
│ │ │ └── named-exports.mjs
│ │ ├── testRequireModule.js
│ │ ├── testStackTrace.js
│ │ └── testUtils.js
│ ├── tsconfig.json
│ └── typescript-tests/
│ ├── demo.ts
│ └── tsconfig.nightwatch.json
└── types/
├── assertions.d.ts
├── chrome-options.d.ts
├── custom-assertion.d.ts
├── custom-command.d.ts
├── desired-capabilities.d.ts
├── expect.d.ts
├── globals.d.ts
├── index.d.ts
├── nightwatch-options.d.ts
├── page-object.d.ts
├── tests/
│ ├── actions.test-d.ts
│ ├── appiumCommands.test-d.ts
│ ├── chromiumClientCommands.test-d.ts
│ ├── clientCommands.test-d.ts
│ ├── component.test-d.ts
│ ├── customCommands.test-d.ts
│ ├── describe.test-d.ts
│ ├── elementCommands.test-d.ts
│ ├── expect.test-d.ts
│ ├── globalElementApi.test-d.ts
│ ├── index.test-d.ts
│ ├── namespaceCommands.test-d.ts
│ ├── page-object.test-d.ts
│ ├── programmaticApi.test-d.ts
│ ├── tsconfig.json
│ ├── webElement.test-d.ts
│ └── webdriverProtocolCommands.test-d.ts
├── utils.d.ts
└── web-element.d.ts
================================================
FILE CONTENTS
================================================
================================================
FILE: .eslintignore
================================================
node_modules
package.json
*.json
lib/utils/requireModule.js
lib/reporter/reporters/html
dist
================================================
FILE: .eslintrc
================================================
{
"root": true,
"extends": [
"eslint:recommended"
],
"parserOptions": {
"ecmaVersion": 13,
"sourceType": "module",
"ecmaFeatures": {
"jsx": false
}
},
"env": {
"mocha": true,
"node": true
},
"overrides": [
{
"files": [
"**/*.ts"
],
"excludedFiles": [
"test/**/*.ts"
],
"extends": [
"eslint:recommended",
"plugin:@typescript-eslint/eslint-recommended",
"plugin:@typescript-eslint/recommended"
],
"parser": "@typescript-eslint/parser",
"plugins": [
"@typescript-eslint"
],
"parserOptions": {
"ecmaVersion": 2020,
"sourceType": "module",
"ecmaFeatures": {
"jsx": false
},
"project": "./tsconfig.json"
}
}
],
"rules": {
"eqeqeq": [
"error",
"smart"
],
"no-extra-boolean-cast": 0,
"quotes": [
"error",
"single"
],
"curly": [
"error",
"all"
],
"no-console": [
"error",
{
"allow": [
"error"
]
}
],
"no-debugger": 1,
"semi": [
"error",
"always",
{
"omitLastInOneLineBlock": true
}
],
"no-trailing-spaces": 1,
"no-else-return": 2,
"no-extra-bind": 0,
"no-implicit-coercion": 0,
"no-useless-call": 0,
"no-return-assign": 0,
"eol-last": 1,
"no-unused-vars": 0,
"no-extra-semi": 0,
"comma-dangle": 2,
"no-underscore-dangle": 0,
"no-lone-blocks": 0,
"array-bracket-spacing": 2,
"object-curly-spacing": 2,
"brace-style": [
2,
"1tbs",
{
"allowSingleLine": true
}
],
"comma-spacing": 2,
"comma-style": 2,
"key-spacing": 2,
"one-var": [
"error",
"never"
],
"semi-style": [
"error",
"last"
],
"space-in-parens": [
"error",
"never"
],
"keyword-spacing": [
2,
{
"before": true,
"after": true
}
],
"space-infix-ops": 1,
"padding-line-between-statements": [
"error",
{
"blankLine": "always",
"prev": "*",
"next": "return"
}
],
"indent": [
"error",
2,
{
"SwitchCase": 1
}
],
"prefer-const": [
"warn"
]
},
"globals": {
"Promise": true,
"Proxy": true,
"Set": true,
"Reflect": true,
"element": "readonly",
"by": "readonly",
"expect": "readonly",
"browser": "readonly",
"app": "readonly",
"Key": "readonly"
}
}
================================================
FILE: .github/FUNDING.yml
================================================
open_collective: nightwatch
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.yml
================================================
name: "Bug Report"
description: "File a bug report to help us improve Nightwatch."
body:
- type: "markdown"
attributes:
value: |
Thanks in advance for your contribution. Before submitting a new issue, try searching for a similar one here: https://github.com/nightwatchjs/nightwatch/search?type=Issues.
- type: "textarea"
id: "description"
attributes:
label: "Description of the bug/issue"
description: "A brief description of the issue, how to reproduce it, and the expected behavior."
placeholder: |
When I ____, I expected ____ to happen but ____ happened instead.
validations:
required: true
- type: "textarea"
id: "steps"
attributes:
label: "Steps to reproduce"
description: |
Explain how to cause the issue in the provided reproduction.
value: |
1. Go to '...'
2. Click on '...'
3. Scroll down to '...'
4. See error
- type: textarea
id: "sample-test"
attributes:
label: "Sample test"
description:
Include a sample test that reproduces the problem you're experiencing. If possible, the test should be against a public URL.
Please add the test and other info inline, not as attachments or screenshots.
placeholder: |
// Please add the sample test here
module.exports = {
sampleTest: function() {
browser
.navigateTo('<URL here>')
.click('<selector>')
.end();
}
}
render: node
- type: textarea
id: "run-with-command"
attributes:
label: "Command to run"
description: "Include the command used to run the test."
placeholder: |
nightwatch test/sampleTest.js --your-other-arguments-here
render: bash
- type: textarea
id: "verbose-output"
attributes:
label: "Verbose Output"
description: |
"Extended nightwatch command logging during the session.
Please use nightwatch --verbose and paste the output here"
placeholder: |
[Sample Test] Test Suite
────────────────────────────────────────────────────────
⠋ Starting ChromeDriver on port 9515...
Request POST /session
{
desiredCapabilities: {
browserName: 'chrome',
'goog:chromeOptions': { w3c: true, args: [] },
name: 'Sample Test'
},
capabilities: {
alwaysMatch: {
browserName: 'chrome',
'goog:chromeOptions': { w3c: true, args: [] }
}
}
render: fundamental
- type: textarea
id: "configuration"
attributes:
label: "Nightwatch Configuration"
description: "Add your nightwatch.json or nightwatch.conf.js here; Make sure to leave out any sensitive details."
placeholder: |
module.exports = {
src_folders: [],
page_objects_path: [],
custom_commands_path: [],
custom_assertions_path: '',
plugins: [],
globals_path: '',
webdriver: {},
test_settings: {}
}
render: node
- type: "markdown"
attributes:
value: |
## Your Environment
Include the relevant details related to your environment.
- type: "input"
id: "nightwatch-version"
attributes:
label: "Nightwatch.js Version"
description: "The version of Nightwatch you are using. Run: nightwatch --version"
placeholder: "2.3.0"
validations:
required: true
- type: "input"
id: "node-version"
attributes:
label: "Node Version"
description: "The version of Node you are using."
placeholder: "14.0.0"
- type: "input"
id: "browser"
attributes:
label: "Browser"
description: "The browser(s) this issue occurred with."
placeholder: "Firefox 102.0.1; Chrome 104.0.0"
- type: "input"
id: "operating-system"
attributes:
label: "Operating System"
description: "The operating system(s) this issue occurred with."
placeholder: "MacOs Monterey 12.5"
- type: "textarea"
id: "additional-information"
attributes:
label: "Additional Information"
description: |
Use this section to provide any additional information you might have
like screenshots, notes, or links to ideas.
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
contact_links:
- name: Ask a question
url: https://github.com/nightwatchjs/nightwatch/discussions
about: Ask questions and discuss topics with other community members
- name: Documentation Request
url: https://github.com/nightwatchjs/nightwatch-docs/issues/new
about: Request for documentation to be added/altered
- name: Chat with other community members. Ask support questions, discuss news and feature requests.
url: https://discord.gg/x5RuXc6Z
about: The official Nightwatchjs Discord community
================================================
FILE: .github/ISSUE_TEMPLATE/feature-request.yml
================================================
name: "Feature Request"
description: "Request a feature or enhancement for Nightwatch"
labels: ["enhancement"]
body:
- type: "markdown"
attributes:
value: |
Thanks in advance for your contribution. Before requesting a new feature, try searching for a similar issue here: https://github.com/nightwatchjs/nightwatch/search?type=Issues.
- type: "textarea"
id: "description"
attributes:
label: "Description"
description: "Please describe your request in one or two sentences."
validations:
required: true
- type: "textarea"
id: "proposed-solution"
attributes:
label: "Suggested solution"
description: |
Please provide code snippets, gists, or links to the ideal
design or API.
- type: "textarea"
id: "alternatives"
attributes:
label: "Alternatives / Workarounds"
description: |
What alternative solutions have you considered before making this
request?
- type: "textarea"
id: "additional-information"
attributes:
label: "Additional Information"
description: |
What resources (links, screenshots, etc.) do you have to assist this
effort?
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
Thanks in advance for your contribution. Please follow the below steps in submitting a pull request, as it will help us with reviewing it quicker.
- [ ] Before marking your PR for review, please test and verify your changes by making appropriate modifications to any of the Nightwatch example tests (present in `examples/tests` directory of the project) and running them. `ecosia.js` and `duckDuckGo.js` are good examples to work with.
- [ ] Create a new branch from master (e.g. `features/my-new-feature` or `issue/123-my-bugfix`);
- [ ] If you're fixing a bug also create an issue if one doesn't exist yet;
- [ ] If it's a new feature explain why do you think it's necessary. Please check with the maintainers beforehand to make sure it is something that we will accept. Usually we only accept new features if we feel that they will benefit the entire community;
- [ ] Please avoid sending PRs which contain drastic or low level changes. If you are certain that the changes are needed, please discuss them beforehand and indicate what the impact will be;
- [ ] If your change is based on existing functionality please consider refactoring first. Pull requests that duplicate code will most likely be ignored;
- [ ] Do not include changes that are not related to the issue at hand;
- [ ] Follow the same coding style with regards to spaces, semicolons, variable naming etc.;
- [ ] Always add unit tests - PRs without tests are most of the times ignored.
================================================
FILE: .github/label-commenter-config.yml
================================================
# Configuration for Label Commenter - https://github.com/peaceiris/actions-label-commenter
labels:
- name: needs-triaging
labeled:
issue:
body: |
@{{ issue.user.login }}, thank you for creating this issue. We will troubleshoot it as soon as we can.
---
<details>
<summary>Info for maintainers</summary>
<div>
<br>
<p>
Triage this issue by using labels.
</p>
<p>
If information is missing, add a helpful comment and add the <code>I-issue-template</code> label.
</p>
<p>
Thank you!
</p>
</div>
</details>
- name: I-issue-template
labeled:
issue:
body: |
Hi, @{{ issue.user.login }}.
Please follow the issue template, we need more information to reproduce the issue.
Either a complete code snippet (if more than one file is needed, provide a GitHub repo and instructions to run the code), the specific versions used, or a more detailed description to help us understand the issue.
Reply to this issue when all information is provided, thank you.
================================================
FILE: .github/stale.yml
================================================
# Number of days of inactivity before an issue becomes stale
daysUntilStale: 90
# Number of days of inactivity before a stale issue is closed
daysUntilClose: 7
# Issues with these labels will never be considered stale
exemptLabels:
- META
- pinned
- enhancement
# Label to use when marking an issue as stale
staleLabel: stale
# Comment to post when marking an issue as stale. Set to `false` to disable
markComment: >
This issue has been automatically marked as stale because it has not had any recent activity.
If possible, please retry using the latest Nightwatch version and update the issue with any relevant details.
If no further activity occurs, it will be closed. Thank you for your contribution.
# Comment to post when closing a stale issue. Set to `false` to disable
closeComment: false
================================================
FILE: .github/workflows/build-node.yaml
================================================
# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
name: tests
on:
push:
branches: [ main]
pull_request:
branches: [ main]
jobs:
linux:
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node-version: [18.x, 20.x, 22.x, 24.x]
# See supported Node.js release schedule at https://nodejs.org/en/about/releases/
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: npm run eslint
- run: npm test
windows:
runs-on: windows-latest
strategy:
fail-fast: false
matrix:
node-version: [18.x, 20.x, 22.x, 24.x]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: npm run eslint
- run: npm test
================================================
FILE: .github/workflows/component-tests.yaml
================================================
name: component-tests
on:
push:
branches: [ main]
pull_request:
branches: [ main]
jobs:
linux:
runs-on: ubuntu-latest
strategy:
matrix:
node-version: [18.x]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
# - run: npm i @nightwatch/react @nightwatch/vue @testing-library/dom vite-plugin-nightwatch vue react react-dom
# - run: npm run component-tests
================================================
FILE: .github/workflows/coverage.yml
================================================
# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
name: Coverage Job
on:
push:
branches: [ ]
pull_request:
branches: [ ]
jobs:
build:
runs-on: ubuntu-latest
strategy:
matrix:
node-version: [18.x]
# See supported Node.js release schedule at https://nodejs.org/en/about/releases/
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: npm run eslint
- run: npm run mocha-coverage
- run: npm run coverage
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v1
with:
token: ${{ secrets.CODECOV_ACCESS_TOKEN }}
files: ./coverage/mocha_coverage.lcov
flags: unittests
name: codecov-umbrella
fail_ci_if_error: true
path_to_write_report: codecov_report.txt
verbose: false
================================================
FILE: .github/workflows/label-commenter.yml
================================================
# Configuration for Label Commenter - https://github.com/peaceiris/actions-label-commenter
name: Label Commenter
on:
issues:
types: [ labeled ]
permissions:
contents: read
issues: write
jobs:
comment:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v2
- name: Label Commenter
uses: peaceiris/actions-label-commenter@v1
================================================
FILE: .github/workflows/missing-types-comment.yml
================================================
name: Add comment for missing types
on:
workflow_run:
workflows: ["Check missing types"]
types:
- completed
jobs:
add_comment:
runs-on: ubuntu-latest
if: >
github.event.workflow_run.event == 'pull_request' &&
github.event.workflow_run.conclusion == 'success'
steps:
- name: 'Download artifact'
uses: actions/github-script@v6
with:
script: |
var artifacts = await github.rest.actions.listWorkflowRunArtifacts({
owner: context.repo.owner,
repo: context.repo.repo,
run_id: ${{github.event.workflow_run.id }},
});
var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
return artifact.name == "pr"
})[0];
var download = await github.rest.actions.downloadArtifact({
owner: context.repo.owner,
repo: context.repo.repo,
artifact_id: matchArtifact.id,
archive_format: 'zip',
});
var fs = require('fs');
fs.writeFileSync('${{github.workspace}}/pr.zip', Buffer.from(download.data));
- name: 'Read artifact'
id: modified-files
run: |
unzip pr.zip
cat files_changed
echo "modified=$(cat files_changed)" >> "$GITHUB_OUTPUT"
- name: Comment on PR
if: steps.modified-files.outputs.modified == ''
id: comment-on-pr
uses: actions/github-script@v6
with:
script: |
const fs = require('fs');
const issue_number = Number(fs.readFileSync('./NR'));
const comment = `
## Status
* ❌ No modified files found in the **types** directory.
Please make sure to include types for any changes you have made. Thank you!.`;
const pullRequest = await github.rest.pulls.get({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: issue_number
});
const comments = await github.rest.issues.listComments({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: issue_number
});
const existingComment = comments.data.find(comment => comment.user.login === 'github-actions[bot]' && comment.body.includes('No modified files found in the **types** director'));
if (existingComment) {
console.log('Comment already exists');
} else {
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: issue_number,
body: comment
});
}
- name: Edit comment on PR
if: steps.modified-files.outputs.modified != ''
uses: actions/github-script@v6
with:
script: |
const fs = require('fs');
const issue_number = Number(fs.readFileSync('./NR'));
const comment = `
## Status
* :white_check_mark: Type files updated!`;
const comments = await github.rest.issues.listComments({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: issue_number
});
const existingComment = comments.data.find(comment => comment.user.login === 'github-actions[bot]' && comment.body.includes('No modified files found in the **types** director'));
if (existingComment) {
await github.rest.issues.updateComment({
owner: context.repo.owner,
repo: context.repo.repo,
comment_id: existingComment.id,
body: comment
});
}
================================================
FILE: .github/workflows/missing-types.yml
================================================
name: Check missing types
on: pull_request
jobs:
detect-modified-files:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Get modified files
id: modified-files
run: |
echo $(git diff --name-only origin/$GITHUB_BASE_REF $GITHUB_SHA types/ | tr '\n' ',')
mkdir -p ./pr
echo $(git diff --name-only origin/$GITHUB_BASE_REF $GITHUB_SHA types/ | tr '\n' ',') > ./pr/files_changed
echo ${{ github.event.number }} > ./pr/NR
- uses: actions/upload-artifact@v4
with:
name: pr
path: pr/
================================================
FILE: .github/workflows/nightly.yml
================================================
name: Nightly
on:
workflow_dispatch:
inputs:
version:
description: Nightly version
required: false
type: string
default: ''
ref:
description: Branch, tag, or SHA to release
required: false
type: string
default: ''
jobs:
nightly:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
with:
ref: ${{ inputs.ref }}
- name: Setup Node
uses: actions/setup-node@v3
with:
node-version: '18.x'
- name: Install dependencies
run: npm install
- name: Build Nightwatch
run: npm run build
- name: Create publishable package 📦
run: npm pack
- name: Release Nightly
uses: marvinpinto/action-automatic-releases@latest
with:
repo_token: "${{ secrets.GITHUB_TOKEN }}"
automatic_release_tag: "nightly-${{ inputs.version }}"
title: "Nightly ${{ inputs.version }}"
prerelease: true
files: '*.tgz'
================================================
FILE: .github/workflows/publish.yml
================================================
name: Publish to NPM
on:
push:
tags:
- vv* # to enable this action, change this tag back to v*
jobs:
publish:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Setup Node
uses: actions/setup-node@v4
with:
node-version: '20.x'
registry-url: 'https://registry.npmjs.org'
- name: Install dependencies
run: npm install
- name: Publish package on NPM 📦
run: npm publish
env:
NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
================================================
FILE: .github/workflows/type-declaration-tests.yml
================================================
name: Type Declaration Tests
on:
push:
branches: [main, feat/types-test]
pull_request:
branches: [main]
jobs:
linux:
runs-on: ubuntu-latest
strategy:
matrix:
node-version: [18.x]
typescript-version: [3.9, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- name: Install TypeScript
run: npm install -g typescript@${{ matrix.typescript-version }}
- name: Install Dependencies
run: npm ci
- run: npm run test:types
================================================
FILE: .gitignore
================================================
.project
.DS_Store
*.vim
*.idea
*.vscode
*.log
*.env
/nightwatch.json
/nightwatch.conf.js
node_modules
dist
npm-debug.log
lib-cov
coverage.html
selenium-debug.log
phantomjsdriver.log
tests_output
*~
\#*
\.#*
output
/test/hooks_output
/bin/geckodriver*
/coverage/
/.nyc_output/
screenshot.png
/sample
/screens
/logs
html-report/
test-results.xml
chromedriver-mobile/
*.sw[po]
snapshot.html
================================================
FILE: .husky/pre-commit
================================================
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"
npx lint-staged
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, gender, gender identity and expression, sex characteristics, disability, ethnicity, level of experience, education, socio-economic status, nationality, personal appearance, body size, race, religion (or lack thereof), or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language - please read the [inclusive language guidance](https://www.uua.org/lgbtq/welcoming/ways/200008.shtml) from the UUA
* Being respectful of differing viewpoints and experiences
* Showing empathy towards other community members
* Gracefully accepting constructive criticism
* Exercising consideration and respect in your speech and actions
* Attempting collaboration before conflict or criticism
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, spamming, intentionally disrupting conversations, making insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing or threatening to publish others' private information, such as a physical or electronic address, without explicit permission
* Advocating for, or encouraging, any of the above behavior
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at hello@pineview.io. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html.
It's inspired among other things by:
- [Citizen Code of Conduct](http://citizencodeofconduct.org/)
- [Appium](https://github.com/appium/appium/blob/master/CONDUCT.md)
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Nightwatch
Contributions to Nightwatch are always welcome but please try to follow these guidelines when sending in something as it will help addressing the issue quicker and more smoothly.
__Please do not ask for assistance in the Issues list.__ Join our [Discord server](https://discord.com/invite/SN8Da2X) to ask questions and seek help.
Assistance requests posted in the Issues list are usually closed right away.
## Code of Conduct
Contributors are expected to adhere to the [Code of Conduct](CODE_OF_CONDUCT.md).
## Submit an issue
Before submitting a new issues, try searching for a similar one here: https://github.com/nightwatchjs/nightwatch/search?type=Issues and add your scenario there and anything else which you think will help with fixing it;
If you are filing a bug report, regression issue or what it appears to be strange behaviour, please follow the steps below:
1. Please write an elaborate title which explains the problem as accurate as possible
For instance:
- __not helpful__: "Issue with tags"
- __much better__: "Tags don't work when combined with --skiptags option"
2. Include a sample test which reproduces the problem you're experiencing. The test should be against a __public url__. The test and other info should be posted inline, attachments will be ignored;
3. Include the verbose output, if possible (run nightwatch with `--verbose` argument);
4. Include your configuration (try to leave out the irrelevant bits);
5. Also include: Nightwatch version, Node.js version, OS version and Webdriver/Selenium Server version;
6. Please try not to report issues you have with individual browser drivers which cannot or should not be solved in Nightwatch.
## Requesting a feature
Feature requests are welcome.
1. Indicate in the issue title that it is a feature/enhancement request;
2. Explain the use case and include a sample test case and/or usage, if possible;
3. Try to submit enhancements that you cannot build with custom commands/assertions and something that will benefit the community;
4. Same as for issues, add your comments/vote to an existing feature request if you'd like to see it implemented.
## Submitting a pull request
Thanks in advance for your contribution.
1. Follow the usual git workflow for submitting a pull request:
- Fork and clone the project.
- Create a new branch from main (e.g. `features/my-new-feature` or `issue/123-my-bugfix`).
- Add your changes.
- Try to run some Nightwatch example tests locally to test the functionality after making your changes: `node ./bin/nightwatch examples/tests/ecosia.js --env chrome`.
- Run Nightwatch unit tests locally: `npm test`;
Or, run individual tests: `npx mocha test/src/api/commands/client/testWaitUntil.js`.
- Commit your changes and create a pull request.
__Note:__ When running Nightwatch example test for the first time, if you encounter _"Cannot read source"_ error, go to `nightwatch.conf.js` file and set 'page_objects_path' and 'custom_commands_path' configs to `[]`.
2. If you're fixing a bug, also create an issue if one doesn't exist yet.
3. If it's a new feature/enhancement, explain why do you think it's necessary.
4. If your change include drastic or low level changes please discuss them to make sure they will be accepted and what the impact will be.
5. If your change is based on existing functionality, please consider refactoring first. Pull requests that duplicate code will not make it in very quick, if at all.
6. Do not include changes that are not related to the issue at hand.
7. Follow the same coding style with regards to spaces, semicolons, variable naming etc.
8. Always add tests - after all this _is_ a testing framework.
================================================
FILE: LICENSE.md
================================================
The MIT License (MIT)
Copyright (c) 2014-2021, Pine View Software AS. https://pineview.io
Copyright (c) 2022, BrowserStack Limited. https://www.browserstack.com
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# Nightwatch.js
[](https://www.npmjs.com/package/nightwatch)
[](https://github.com/nightwatchjs/nightwatch/actions/workflows/build-node.yaml)
[](https://codecov.io/gh/nightwatchjs/nightwatch)
[![Discord][discord-badge]][discord]
<p align="center">
<img alt="Nightwatch.js Logo" src="https://raw.githubusercontent.com/nightwatchjs/nightwatch/main/.github/assets/nightwatch-logo.png" width=300 />
</p>
#### [Homepage](https://nightwatchjs.org) • [Developer Guide](https://nightwatchjs.org/guide) • [API Reference](https://nightwatchjs.org/api) • [About](https://nightwatchjs.org/about) • [Blog](https://nightwatchjs.org/blog)
Nightwatch is an integrated testing framework powered by Node.js and using the [W3C Webdriver API](https://www.w3.org/TR/webdriver/). It is a complete testing solution developed at [BrowserStack](https://www.browserstack.com/) and which can be used for:
☑️ end-to-end testing of web applications and websites
☑️ component testing in isolation (React / Vue / Storybook / Angular)
☑️ Node.js unit, visual regression testing, accessibility testing & API testing
☑️ Native mobile app testing on Android & iOS
## 🚀 Nightwatch v3
[What's New](https://nightwatchjs.org/guide/overview/whats-new-in-v3.html) | [Release Notes](https://github.com/nightwatchjs/nightwatch/releases/tag/v3.0.1) | [Discussions](https://github.com/nightwatchjs/nightwatch/discussions)
Nightwatch v3 is an all new generation that has been built around these three pillars:
* **Developer Experience** : The entire experience from getting started, to writing and debugging tests, has been redesigned for speed, stability, and consistent non-flaky results.
* **Mobile first**: Test your web or native, iOS and Android, mobile applications on simulators, real mobile devices or a cloud grid like BrowserStack.
* **One test automation framework**: Run all types of tests from unit, component, and E2E to API, visual, and accessibility with a single framework.
The [Nightwatch v3](https://github.com/nightwatchjs/nightwatch/releases/tag/v3.0.1) is not just a new version, it’s the result of months of engineering effort to reimagine test automation for the future. Try it out in 60 seconds and see it in action.
## ⚙️ Get started in 60 seconds
#### 1. Install Nightwatch from NPM
From your existing project's root dir:
```sh
npm init nightwatch@latest
```
or, if you want to initialize a new project:
```sh
npm init nightwatch@latest ./path/to/new/project
```
#### 2. Answer a few questions about your preferred setup:
- What is your Language - Test Runner setup?
- Where do you want to run your e2e tests?
- Where you'll be testing on?
- Where do you plan to keep your end-to-end tests?
- What is the base_url of your project?
Nightwatch will do the entire setup for you based on your answers.
#### 3. Run a Demo Test:
Nightwatch comes with a few examples, which are automatically copied to your Nightwatch project during the setup and can also be used as boilerplate to write your own tests on top of them.
You can follow the instructions given at the end of the setup to run your first test with Nightwatch.
<img width="413" alt="image" src="https://user-images.githubusercontent.com/39924567/174763723-aff4d501-6320-402c-81cc-de75fbb5e8f0.png">
---
## Nightwatch mobile app testing
Nightwatch enables automation testing of native mobile applications via Appium. It combines the robustness of Appium with the enhanced developer experience provided by Nightwatch. It enables end-to-end functional testing of native mobile apps on Android and iOS devices. Try it now
## Go beyond E2E
### [Component testing](https://nightwatchjs.org/guide/component-testing/introduction.html)
With Nightwatch you can test components in isolation by mounting them in the browser. Nightwatch 2 added support for component testing for popular web frameworks such as
1. [React](https://nightwatchjs.org/guide/component-testing/testing-react-components.html)
2. [VueJS](https://nightwatchjs.org/guide/component-testing/vite-plugin.html)
3. [Angular](https://nightwatchjs.org/guide/component-testing/angular-component-testing.html)
4. [Storybook](https://nightwatchjs.org/guide/component-testing/storybook-component-testing.html)
### Nightwatch unit tests
The tests for Nightwatch are written using Mocha.
1. **Clone the project**
```bash
git clone https://github.com/nightwatchjs/nightwatch.git
# change directory
cd nightwatch
# install the dependencies
npm install
```
2. **Run tests**
To run the complete test suite:
```bash
npm test
```
To check test coverage, run the command:
```bash
npm run mocha-coverage
```
and then open the generated coverage/index.html file in your browser.
See [Unit testing guide](https://nightwatchjs.org/guide/writing-tests/write-nodejs-unit-integration-tests.html) for more details.
### Other types of testing
#### [Visual Regression Testing](https://nightwatchjs.org/guide/writing-tests/visual-regression-testing.html)
Nightwatch v3 introduces visual regression testing as an in-house plugin. The plugin takes care of
1. Capturing screenshots
2. Comparison with baseline to highlight visual differences
3. Report to review the differences
4. Approve the changes
VRT can be done on real desktop & mobile browsers. Also, VRT can be run on components as part of component testing as well.
#### [API Testing](https://nightwatchjs.org/guide/writing-tests/api-testing.html)
API testing is now available with Nightwatch v3. The following functionality can be achieved with API testing
1. Request assertions
2. Response assertions
3. Viewing API tests in the HTML report
4. Mock server
#### [Accessibility Testing](https://nightwatchjs.org/guide/using-nightwatch/accessibility-testing.html)
Nightwatch v3 packages the aXe-core package developed by Deque Systems as a plugin. It enables 90 different types of accessibility tests for WCAG compliance.
## 🦉 About Nightwatch
Nightwatch was initially built by [@pineviewlabs](https://github.com/pineviewlabs/) - an independent software consultancy based in Oslo, Norway, with help from [contributors](https://github.com/nightwatchjs/nightwatch/graphs/contributors). In mid 2021, Nightwatch has become a part of the [@BrowserStack](https://github.com/browserstack) family and it is being developed further at the BrowserStack Open-source Program Office. Read more on [our blog](https://nightwatchjs.org/blog/nightwatch-has-joined-the-browserstack-family.html).
## Contributing
We welcome any and all contributions from the community which can help improve Nightwatch. Please check out [CONTRIBUTING.md](CONTRIBUTING.md) for more extensive contributing guidelines.
## Licence
[MIT](https://github.com/nightwatchjs/nightwatch/blob/main/LICENSE.md)
[discord-badge]: https://img.shields.io/discord/618399631038218240.svg?color=7389D8&labelColor=6A7EC2&logo=discord&logoColor=ffffff&style=flat-square&label=discord
[discord]: https://discord.gg/SN8Da2X
================================================
FILE: api/README.md
================================================
# Nightwatch API Commands
Public commands api exported by Nightwatch in order to be extended upon from outside.
**Example:**
```js
const {Quit: quit} = require('nightwatch/api');
module.exports = CustomQuit extends Quit {
async command(cb = function(r) {return r}) {
console.log('from custom quit command');
await super.command(cb);
}
}
```
**This is a work in progress.**
## Element commands:
- ### Finding elements:
- [findElement](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/findElement.js)
- [findElements](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/findElements.js)
- [element](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/protocol/element.js)
- [elements](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/protocol/elements.js)
- [elementIdElement](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/protocol/elementIdElement.js)
- [elementIdElements](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/protocol/elementIdElements.js)
- [waitForElementPresent](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/waitForElementPresent.js)
- [waitForElementNotPresent](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/waitForElementNotPresent.js)
- [waitForElementVisible](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/waitForElementVisible.js)
- [waitForElementNotVisible](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/waitForElementNotVisible.js)
- ### Element interaction:
- [clearValue](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/clearValue.js)
- [click](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/click.js)
- [moveToElement](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/moveToElement.js)
- [setValue](https://github.com/nightwatchjs/nightwatch/blob/main/lib/api/element-commands/setValue.js)
- ### Element state:
- ### Element location:
- ### Element location:
## Document handling:
## Session related:
## Navigation:
## Window related:
## Frames:
## User actions:
## User prompts:
## Mobile related:
## Utilities & Debugging:
================================================
FILE: api/index.js
================================================
const path = require('path');
const exportedCommands = [
'element-commands/findElement.js',
'element-commands/findElements.js',
'element-commands/element.js',
'element-commands/elements.js',
'element-commands/elementIdElement.js',
'element-commands/elementIdElements.js',
'element-commands/waitForElementPresent.js',
'element-commands/waitForElementNotPresent.js',
'element-commands/waitForElementVisible.js',
'element-commands/waitForElementNotVisible.js',
'protocol/quit.js'
];
const basePath = '../lib/api';
const Commands = {};
const props = exportedCommands.reduce((prev, fileName) => {
const commandName = fileName.substring(fileName.lastIndexOf('/') + 1).replace('.js', '');
prev[commandName] = {
configurable: true,
get: function() {
return require(path.join(basePath, fileName));
}
};
return prev;
}, {});
Object.defineProperties(Commands, props);
module.exports = Commands;
================================================
FILE: bin/.gitignore
================================================
selenium-server-standalone-*
chromedriver
chromedriver-*
phantomjs
IEDriverServer_*
================================================
FILE: bin/nightwatch
================================================
#!/usr/bin/env node
const semver = require('semver');
const {Logger} = require('../lib/utils');
const requiredVersion = require('../package.json').engines.node;
function checkNodeVersion (wanted, id) {
if (!semver.satisfies(process.version, wanted)) {
Logger.error('You are using Node ' + process.version + ', but this version of ' + id +
' requires Node ' + wanted + '.\nPlease upgrade your Node version.'
);
process.exit(1);
}
}
checkNodeVersion(requiredVersion, 'nightwatch');
require('./runner.js');
================================================
FILE: bin/runner.js
================================================
/**
* Module dependencies
*/
const Nightwatch = require('../lib/index.js');
const {Logger, shouldReplaceStack, alwaysDisplayError} = require('../lib/utils');
try {
Nightwatch.cli(function (argv) {
argv._source = argv['_'].slice(0);
const runner = Nightwatch.CliRunner(argv);
return runner
.setupAsync()
.catch((err) => {
if (err.code === 'ERR_REQUIRE_ESM') {
err.showTrace = false;
}
throw err;
})
.then(() => runner.runTests())
.catch((err) => {
if (!err.displayed || (alwaysDisplayError(err) && !err.displayed)) {
Logger.error(err);
}
runner.processListener.setExitCode(10).exit();
});
});
} catch (err) {
const {message} = err;
err.message = 'An error occurred while trying to start the Nightwatch Runner:';
err.showTrace = !shouldReplaceStack(err);
err.detailedErr = message;
Logger.error(err);
process.exit(2);
}
================================================
FILE: bin/show_survey.js
================================================
#!/usr/bin/env node
// eslint-disable-next-line
console.log('\t 👋 Hey there! Thanks for installing Nightwatch. \n\n\tPlease let us know what features you\'d like to see \n\tin Nightwatch v2.0 by taking this quick survey: \n\n\t\thttps://forms.gle/zBhbjdsDE77hTHSB7\n');
================================================
FILE: codecov.yml
================================================
codecov:
require_ci_to_pass: yes
coverage:
precision: 2
round: down
range: "70...100"
parsers:
gcov:
branch_detection:
conditional: yes
loop: yes
method: no
macro: no
comment: false
================================================
FILE: examples/.gitignore
================================================
reports
screens
================================================
FILE: examples/cucumber-js/README.md
================================================
# Using Cucumber.js with Nightwatch 2
Nightwatch 2 brings integrated support for using [Cucumber.js](https://cucumber.io/) directly as an alternative test runner. No other plugins are necessary, other than the [Cucumber library](https://www.npmjs.com/package/@cucumber/cucumber) itself (version 7.3 or higher).
Simply run the following in the same project where Nightwatch is also installed:
```sh
$ npm i @cucumber/cucumber --save-dev
```
## Configuration
```js
{
test_runner: {
// set cucumber as the runner
type: 'cucumber',
// define cucumber specific options
options: {
//set the feature path
feature_path: 'examples/cucumber-js/*/*.feature',
// start the webdriver session automatically (enabled by default)
auto_start_session: true,
// use parallel execution in Cucumber
parallel: 2 // set number of workers to use (can also be defined in the cli as --parallel 2
}
},
src_folders: ['examples/cucumber-js/features/step_definitions']
}
```
## CLI Options
| option | description |
|------------------------|------------------------------|
| `--dry-run` | Do all the aggregation work of looking at your feature files, loading your support code etc but without actually executing the tests. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/dry_run.md)
| `--name` | Specify a scenario by its name matching a regular expression. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#running-specific-features)
| `--tags` | Use tags to run specific scenario or features. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#tags)
| `--require` | Use `--require <GLOB OR DIR OR FILE>` to explicitly require support files before executing the features. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#requiring-support-files)
| `--format` | Use `--format <TYPE[:PATH]>` to specify the format of the output. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#formats)
| `--format-options` | Many formatters, including the built-in ones, support some configurability via options. You can provide this data as a JSON literal via the --format-options CLI option. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/formatters.md#options)
| `--fail-fast` | Abort the run on first failure (default: false). [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#--fail-fast)
| `--retries` | Use `--retries <NUMBER-OF-ATTEMPT>` to have Cucumber attempt it multiple times until either it passes or the maximum number of attempts is reached. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/retry.md#retry)
| `--retry-tag-filter` | Use `--retry-tag-filter` to retry failed scenarios based on tags. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/retry.md#targeting-scenarios)
| `--require-module` | [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md#transpilation)
| `--no-strict` | By default, cucumber runner works in strict mode, meaning it will fail if there are pending steps.
| `--parallel` | Use `--parallel <NUMBER-OF-WORKER-THREADS>` to run your scenarios in parallel. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/parallel.md#parallel)
| `--profile` | As of now only `cucumber.js` is considered while picking up profiles. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/profiles.md)
| `--world-parameters` | Provide this data as a JSON literal via the `--world-parameters`. [read more](https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/world.md#world-parameters)
## Running
Cucumber spec files/step definition files can be provided in `src_folders` in Nightwatch config or as a CLI argument.
With `src_folders` defined:
```sh
$ npx nightwatch
```
Without `src_folders` defined:
```sh
$ npx nightwatch examples/cucumber-js/features/step_definitions
```
Parallel running using 2 workers:
```sh
$ nightwatch examples/cucumber-js/features/step_definitions --parallel 2
```
Use other [test runner options](https://nightwatchjs.org/guide/running-tests/command-line-options.html) as usual:
```sh
$ npx nightwatch examples/cucumber-js/features/step_definitions --headless
```
## Disable the automatic session start
You might need sometimes to not start the Webdriver session automatically after Nightwatch is instantiated. For this purpose, Nightwatch provides the instance available as `this.client`, which contains an `launchBrowser()` method.
### Configuration:
```js
test_runner: {
type: 'cucumber',
options: {
feature_path: 'examples/cucumber-js/*/*.feature',
auto_start_session: false
}
}
```
You can then use an extra setup file that you can pass as an extra `--require` to Nightwatch, which will be forwarded to Cucumber. In the extra setup file, you can add other operations needed to be executed before the session is started.
#### Example _extra_setup.js:
Remember to set the `browser` on `this` so it can be closed automatically by Nightwatch. Otherwise, remember to call `.quit()` in your own Cucumber `After()` hooks.
```js
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();
});
```
#### Nightwatch setup file for Cucumber
You might also want to inspect the built-in setup file that Nightwatch uses for initializing the Cucumber runner. It is available in our project root folder at [/cucumber-js/_setup_cucumber_runner.js](https://github.com/nightwatchjs/nightwatch/blob/v2/cucumber-js/_setup_cucumber_runner.js).
#### Run with extra setup:
```sh
$ nightwatch examples/cucumber-js/features/step_definitions --require {/full/path/to/_extra_setup.js}
```
## Reporting
When using the integrated Cucumber test runner, you need to use the Cucumber [formatters](https://github.com/cucumber/cucumber-js/blob/main/docs/formatters.md) for generating output.
Nightwatch reporters (like JUnit XML reports or the [global custom reporter](https://nightwatchjs.org/guide/extending-nightwatch/custom-reporter.html)) are not available. The main reason is that reporting is delegated to the Cucumber CLI. You can also [write your own](https://github.com/cucumber/cucumber-js/blob/main/docs/custom_formatters.md) Cucumber formatter.
Nightwatch will forward `--format` and `--format-options` CLI arguments, if present, to Cucumber.
By default, the `progress` formatter is used. Here's how the output looks like when running the example tests in Firefox:
```sh
ℹ Connected to GeckoDriver on port 4444 (1740ms).
Using: firefox (92.0.1) on MAC (20.6.0).
.. ✔ Testing if the page title equals 'Rijksmuseum Amsterdam, home of the Dutch masters' (4ms)
. ✔ Element <#rijksmuseum-app> was visible after 46 milliseconds.
. ✔ Testing if element <.search-results> contains text 'Operation Night Watch' (1994ms)
... ✔ Testing if the page title equals 'Rijksmuseum Amsterdam, home of the Dutch masters' (8ms)
. ✔ Element <#rijksmuseum-app> was visible after 49 milliseconds.
. ✔ Testing if element <.search-results> contains text 'The Night Watch, Rembrandt van Rijn, 1642' (1427ms)
.
2 scenarios (2 passed)
10 steps (10 passed)
0m13.024s (executing steps: 0m12.998s)
```
================================================
FILE: examples/cucumber-js/features/nightwatch.feature
================================================
Feature: Google Search
Background: Background name
Given I open the Rijksmuseum page
And I dismiss the cookie dialog
Then the title is "Rijksmuseum Amsterdam, home of the Dutch masters"
@a @b
Scenario: Searching the Rijksmuseum
Given I search "night watch"
Then Body contains "Operation Night Watch"
@a @b
Scenario: Searching the Rijksmuseum-1
Given I search "night watch"
Then Body contains "The Night Watch, Rembrandt van Rijn, 1642"
================================================
FILE: examples/cucumber-js/features/step_definitions/nightwatch.js
================================================
const {Given, Then, When, Before} = require('@cucumber/cucumber');
Given(/^I open the Rijksmuseum page$/, function() {
return browser.navigateTo('https://www.rijksmuseum.nl/en');
});
Given(/^I dismiss the cookie dialog$/, async function() {
const cookieDialogVisible = await browser.isVisible({
selector: '.cookie-consent-bar-wrap',
suppressNotFoundErrors: true
});
if (cookieDialogVisible) {
return browser.click('.cookie-consent-bar-wrap button.link');
}
});
Given(/^I search "([^"]*)"$/, async function(searchTerm) {
// FIXME: chaining the click command to the rest of the commands causes an uncaughtRejection in case of an element locate error
await browser.pause(1000).click('a[aria-label="Search"]');
return browser.waitForElementVisible('#rijksmuseum-app')
.setValue('input.search-bar-input[type=text]', [searchTerm, browser.Keys.ENTER])
.pause(1000);
});
Then(/^the title is "([^"]*)"$/, function(title) {
return browser.assert.titleEquals(title);
});
Then(/^Body contains "([^"]*)"$/, function(contains) {
return browser.assert.textContains('.search-results', contains);
});
================================================
FILE: examples/custom-assertions/testCustomAssertion.js
================================================
const util = require('util');
exports.assertion = function(selector, attribute, expected, msg) {
let DEFAULT_MSG = 'Testing if attribute %s of <%s> contains "%s".';
let MSG_ELEMENT_NOT_FOUND = `${DEFAULT_MSG} Element could not be located.`;
let MSG_ATTR_NOT_FOUND = `${DEFAULT_MSG} Element does not have a ${attribute} attribute.`;
this.message = msg || util.format(DEFAULT_MSG, attribute, selector, expected);
this.expected = function() {
return expected;
};
this.pass = function(value) {
return value === expected;
};
this.failure = function(result) {
let failed = (result === false) ||
// no such element
result && (result.status === -1 || result.value === null);
if (failed) {
let defaultMsg = MSG_ELEMENT_NOT_FOUND;
if (result && result.value === null) {
defaultMsg = MSG_ATTR_NOT_FOUND;
}
this.message = msg || util.format(defaultMsg, attribute, selector, expected);
}
return failed;
};
this.value = function(result) {
return result.value;
};
this.command = function(callback) {
return this.api.getAttribute(selector, attribute, callback);
};
};
================================================
FILE: examples/custom-commands/angular/getElementsInList.js
================================================
module.exports = class AngularCommand {
async command(listName, cb = function(r) {return r}) {
return this.api.executeScript(function(listName) {
// executed in the browser context
// eslint-disable-next-line
var elements = document.querySelectorAll('*[ng-repeat$="'+listName+'"]');
if (elements) {return elements}
// eslint-disable-next-line
return null;
}, [listName], async function(result) {
const cbResult = await cb(result);
if (cbResult.value) {
return cbResult.value;
}
return cbResult;
});
}
};
================================================
FILE: examples/custom-commands/strictClick.js
================================================
module.exports = {
command: function(selector){
return this.waitForElementVisible(selector)
.click(selector);
}
};
================================================
FILE: examples/globals.json
================================================
{
"default" : {
"myGlobal" : 1
},
"test_env" : {
"myGlobal" : 2
}
}
================================================
FILE: examples/globalsModule.js
================================================
module.exports = {
// this controls whether to abort the test execution when an assertion failed and skip the rest
// it's being used in waitFor commands and expect assertions
abortOnAssertionFailure: true,
// this will overwrite the default polling interval (currently 500ms) for waitFor commands
// and expect assertions that use retry
waitForConditionPollInterval: 500,
// default timeout value in milliseconds for waitFor commands and implicit waitFor value for
// expect assertions
waitForConditionTimeout: 5000,
// this will cause waitFor commands on elements to throw an error if multiple
// elements are found using the given locate strategy and selector
throwOnMultipleElementsReturned: false,
// controls the timeout value for async hooks. Expects the done() callback to be invoked within this time
// or an error is thrown
asyncHookTimeout: 10000,
// controls the timeout value for when running async unit tests. Expects the done() callback to be invoked within this time
// or an error is thrown
unitTestsTimeout: 2000,
// controls the timeout value for when executing the global async reporter. Expects the done() callback to be invoked within this time
// or an error is thrown
customReporterCallbackTimeout: 20000,
// Automatically retrying failed assertions - You can tell Nightwatch to automatically retry failed assertions until a given timeout is reached, before the test runner gives up and fails the test.
retryAssertionTimeout: 1000,
'default': {
myGlobal: function() {
return 'I\'m a method';
}
},
'test_env': {
myGlobal: 'test_global',
beforeEach: function() {
}
},
before(cb) {
//console.log('GLOBAL BEFORE')
cb();
},
beforeEach(browser, cb) {
//console.log('GLOBAL beforeEach')
cb();
},
after(cb) {
//console.log('GLOBAL AFTER')
cb();
},
afterEach(browser, cb) {
browser.perform(function() {
//console.log('GLOBAL afterEach')
cb();
});
},
reporter(results, cb) {
cb();
}
};
================================================
FILE: examples/pages/google/consent.js
================================================
class ConsentCommand {
turnOffSearchCustomization() {
this.page.section.customizeSearch.click('@turnOffButton');
return this;
}
turnOffYoutubeHistory() {
this.page.section.youtubeHistory.click('@turnOffButton');
return this;
}
turnOffAdPersonalization() {
this.page.section.adPersonalization.click('@turnOffButton');
return this;
}
confirm() {
this.page.section.consentForm.click('@submitButton');
return this;
}
turnOffEverything() {
return this.turnOffSearchCustomization()
.turnOffYoutubeHistory()
.turnOffAdPersonalization()
.confirm();
}
}
const createSectionFor = (text) => {
return Object.assign({
selector: `//div[contains(.,"${text}")]`,
locateStrategy: 'xpath'
}, {
elements: {
turnOffButton: 'button[aria-label^="Turn off"]'
}
});
};
module.exports = {
url: 'http://google.com',
commands: ConsentCommand,
elements: {
consentModal: 'form[action^="https://consent.google"]'
},
sections: {
customizeSearch: createSectionFor('Search customization'),
youtubeHistory: createSectionFor('YouTube History'),
adPersonalization: createSectionFor('Ad personalization'),
consentForm: {
selector: 'form[action^="https://consent.google"]',
elements: {
submitButton: 'button'
}
}
}
};
================================================
FILE: examples/pages/google/search.js
================================================
const searchCommands = {
submit() {
this.waitForElementVisible('@submitButton', 1000)
.click('@submitButton');
this.pause(1000);
return this; // Return page object for chaining
}
};
const consentModal = '[aria-modal="true"]';
module.exports = {
url: 'https://google.no',
commands: [
searchCommands
],
sections: {
consentModal: {
selector: consentModal,
elements: {
rejectAllButton: '.GzLjMd button:nth-child(1)'
}
}
},
elements: {
consentModal,
searchBar: {
selector: 'textarea[name=q]'
},
submitButton: {
selector: 'input[value="Google Search"]'
}
}
};
================================================
FILE: examples/pages/google/searchResults.js
================================================
const util = require('util');
// starting xpath with './/' tells browser to begin search from the current element,
// while starting with '//' tells browser to begin search from the start of html document.
const menuXpath = './/span[contains(text(), "%s")]';
const menuCommands = {
productIsSelected: function (product, callback) {
var self = this;
return this.getAttribute(product, 'class', function (result) {
const isSelected = result.value.indexOf('hdtb-msel') > -1;
callback.call(self, isSelected);
});
}
};
module.exports = {
elements: {
results: {selector: '#rso'}
},
sections: {
menu: {
selector: 'div[role="navigation"] div[data-st-cnt="mode"]',
commands: [menuCommands],
elements: {
maps: {
selector: util.format(menuXpath, 'Maps'),
locateStrategy: 'xpath',
index: 0
},
videos: {
selector: util.format(menuXpath, 'Videos'),
locateStrategy: 'xpath',
index: 0
},
images: {
selector: util.format(menuXpath, 'Images'),
locateStrategy: 'xpath',
index: 0
},
news: {
selector: util.format(menuXpath, 'News'),
locateStrategy: 'xpath',
index: 0
}
}
}
}
};
================================================
FILE: examples/pages/nightwatchFeatures.js
================================================
const featuresCommands = {
getFeatureCount: function(callback) {
this.api.elements(null, this.elements.features, function (result) {
if (result.status === 0) {
var countResult = {
status: 0,
value: result.value.length
};
callback.call(this, countResult);
} else {
callback.call(this, result);
}
}.bind(this));
return this;
}
};
module.exports = {
commands: [featuresCommands],
elements: {
featuresHeading: {
selector: '#index-container h2',
index: 1
},
features: '#index-container .features h3'
}
};
================================================
FILE: examples/test-app/globals.js
================================================
const waitOn = require('wait-on');
const {spawn} = require('child_process');
const path = require('path');
let serverPid = null;
const serverPort = '13370';
module.exports = {
before(done) {
// serve --listen 13370 ./test-app
serverPid = spawn(path.resolve('node_modules/.bin/serve'), ['--listen', serverPort, '--no-request-logging', __dirname], {
cwd: process.cwd(),
stdio: 'inherit'
}).pid;
waitOn({
resources: [`http://localhost:${serverPort}`]
}).then(() => {
setTimeout(done, 500);
});
},
after() {
if (serverPid) {
process.kill(serverPid);
}
}
};
================================================
FILE: examples/test-app/index.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>nightwatch-testing-library</title>
<style>
blockquote {
margin: 0;
border-left: 4px solid grey;
padding-left: 10px;
color: grey;
}
section {
padding: 10px;
}
</style>
</head>
<body>
<section>
<h2>getByPlaceholderText</h2>
<input type="text" placeholder="Placeholder Text" />
</section>
<section>
<h2>getByText</h2>
<button role="button" onclick="this.innerText = 'Button Clicked'">Unique Button Text</button>
<div id="nested">
<h3>getByText within</h3>
<button onclick="this.innerText = 'Button Clicked'">Button Text</button>
</div>
<div id="nested2" data-testid="nested2">
<h3>getByText within</h3>
<button onclick="this.innerText = 'Button Clicked'">Button Text</button>
<span>text only in 2nd nested</span>
<span>another thing only in 2nd nested</span>
</div>
</section>
<section>
<h2>getByLabelText</h2>
<label for="input-labelled-by-id">Label For Input Labelled By Id</label>
<input type="text" placeholder="Input Labelled By Id" id="input-labelled-by-id" />
</section>
<section>
<h2>getByAltText</h2>
<img src="data:image/png;base64," alt="Image Alt Text" onclick="this.style.border = '5px solid red'" />
</section>
<section>
<h2>getByTestId</h2>
<img data-testid="image-with-random-alt-tag" src="data:image/png;base64,"
onclick="this.style.border = '5px solid red'" />
</section>
<section>
<h2>configure</h2>
<img data-automation-id="image-with-random-alt-tag" src="data:image/png;base64,"
onclick="this.style.border = '5px solid red'" />
</section>
<section>
<h2>configure standalone</h2>
<img data-other-test-id="other-id" src="data:image/png;base64," onclick="this.style.border = '5px solid red'" />
</section>
<section>
<h2>getAllByText</h2>
<button onclick="this.innerText = ''">Thales of Miletus</button>
<button onclick="this.innerText = ''">Anaximander of Miletus</button>
</section>
<section>
<h2>navigate</h2>
<a href="page2.html">Go to Page 2</a>
</section>
<script>
document
.querySelector('[data-testid="image-with-random-alt-tag"]')
.setAttribute("alt", "Image Random Alt Text " + Math.random());
</script>
</body>
</html>
================================================
FILE: examples/test-app/page2.html
================================================
<div>
<h2>second page</h2>
</div>
<section>
<section>
<h2>configure</h2>
<img data-automation-id="page2-thing" src="data:image/png;base64,"
onclick="this.style.border = '5px solid red'" />
</section>
</section>
================================================
FILE: examples/tests/README.md
================================================
# Using Mocha as a test runner in Nightwatch 2
Nightwatch 2 brings support for Mocha v9 as an alternative test runner which contains most of the existing functionality from the Nightwatch default runner.
We are still in the process of updating the examples. Please check back here soon.
================================================
FILE: examples/tests/angularTodoTest.js
================================================
describe('angularjs homepage todo list', function() {
it('should add a todo using custom commands', async function(browser) {
// adding a new task to the list
const elements = await browser
.navigateTo('https://angularjs.org')
.sendKeys('[ng-model="todoList.todoText"]', 'what is nightwatch?')
.click('[value="add"]')
.angular.getElementsInList('todoList.todos');
const taskEl = element(elements[2]);
// verifying if the third task is the one we have just added
// browser.assert.textEquals(taskEl, 'what is nightwatch?');
await expect(taskEl).text.toEqual('what is nightwatch?');
// find our task in the list and mark it as done
const inputElement = await element(elements[2]).findElement('input');
await browser.click(inputElement);
// verify if there are 2 tasks which are marked as done in the list
await expect.elements('*[module=todoApp] li .done-true').count.to.equal(2);
});
});
================================================
FILE: examples/tests/bstackdemo/auth.js
================================================
describe('Authentication Tests', function () {
beforeEach((browser) => browser.navigateTo('https://www.bstackdemo.com'));
it('Login test', function () {
browser
.click('#signin')
.setValue('#username input', ['demouser', browser.Keys.ENTER])
.setValue('#password input', ['testingisfun99', browser.Keys.ENTER])
.click('#login-btn')
.assert.textEquals('.username', 'demouser', 'demouser had logged in successfuly.');
});
it('Locked account test', function () {
browser
.click('#signin')
.setValue('#username input', ['locked_user', browser.Keys.ENTER])
.setValue('#password input', ['testingisfun99', browser.Keys.ENTER])
.click('#login-btn')
.assert.textContains('.api-error', 'Your account has been locked.');
});
afterEach((browser) => browser.end());
});
================================================
FILE: examples/tests/bstackdemo/checkout.js
================================================
describe('Checkout Test', function () {
before((browser) => browser.navigateTo('https://www.bstackdemo.com/'));
it('checkout products on bstackdemo.com', function (browser) {
browser
.waitForElementVisible('body')
.assert.titleContains('StackDemo')
// Filter Google from the avaialble filters
.click('input[value=\'Google\'] + span')
.assert.selected('input[value=\'Google\']')
// Add different phones to cart
.click('[id="17"] .shelf-item__buy-btn')
.click('[id="18"] .shelf-item__buy-btn')
.assert.elementsCount('.float-cart__shelf-container .shelf-item', 2)
// Click checkout
.click('.buy-btn')
// Loging with given credentials
.setValue('#username input', ['demouser', browser.Keys.ENTER])
.setValue('#password input', ['testingisfun99', browser.Keys.ENTER])
.click('#login-btn')
// Fill shipping details
.setValue('#firstNameInput', 'John')
.setValue('#lastNameInput', 'Doe')
.setValue('#addressLine1Input', 'localhost')
.setValue('#provinceInput', 'local')
.setValue('#postCodeInput', '127001')
.click('#checkout-shipping-continue')
// Check order successfully placed
.assert.textEquals('#confirmation-message', 'Your Order has been successfully placed.');
});
after((browser) => browser.end());
});
================================================
FILE: examples/tests/chromeCDP_example.js
================================================
describe('Chrome DevTools Example', function() {
this.disabled = this.argv.env !== 'chrome';
it ('using CDP DOM Snapshot', async function(browser) {
await browser.navigateTo('https://nightwatchjs.org');
const dom = await browser.chrome.sendAndGetDevToolsCommand('DOMSnapshot.captureSnapshot', {
computedStyles: []
});
browser.assert.deepStrictEqual(Object.keys(dom), ['documents', 'strings']);
});
});
================================================
FILE: examples/tests/duckDuckGo.js
================================================
describe('duckduckgo example', function() {
this.tags = ['end-to-end'];
it('Search Nightwatch.js and check results', function(browser) {
browser
.navigateTo('https://duckduckgo.com')
.waitForElementVisible('body')
.assert.visible('input[name="q"]')
.sendKeys('input[name="q"]', ['Nightwatch.js'])
.assert.visible('button[type=submit]')
.click('button[type=submit]')
.assert.textContains('.react-results--main', 'Nightwatch.js');
});
});
================================================
FILE: examples/tests/ecosia.js
================================================
describe('Ecosia.org Demo', function() {
before(browser => {
browser
.navigateTo('https://www.ecosia.org/');
});
it('Demo test ecosia.org', function(browser) {
browser
.waitForElementVisible('body')
.assert.titleContains('Ecosia')
.assert.visible('input[type=search]')
.setValue('input[type=search]', 'nightwatch')
.assert.visible('button[type=submit]')
.click('button[type=submit]')
.assert.textContains('.layout__content', 'Nightwatch.js');
});
after(browser => browser.end());
});
================================================
FILE: examples/tests/element/dragAndDrop.js
================================================
describe('Element Drag & Drop Demo', function () {
before(browser => {
browser.navigateTo(
'https://mdn.github.io/dom-examples/drag-and-drop/copy-move-DataTransfer.html'
);
});
it('move element demo', async function (browser) {
const srcMoveElem = browser.element('#src_move'); // returns a Nightwatch Element Wrapper with loads of element commands.
// pause to see the initial state
browser.pause(1000);
// drag src element 80 pixels below.
srcMoveElem.dragAndDrop({x: 0, y: 80});
});
it('copy element demo', async function (browser) {
const srcCopyElem = browser.element('#src_copy'); // returns a Nightwatch Element Wrapper with loads of element commands.
const destCopyWebElem = await browser.element('#dest_copy'); // awaiting the browser.element command returns a WebElement object (actual result).
// pause to see the initial state
browser.pause(1000);
// drag src element to dest element.
srcCopyElem.dragAndDrop(destCopyWebElem);
});
after((browser) => {
// pause to see the final state
browser.pause(2000);
browser.end();
});
});
================================================
FILE: examples/tests/element/elementScreenshot.js
================================================
describe('Take Screenshot Demo', function () {
before((browser) => {
browser.navigateTo('https://nightwatchjs.org/');
});
it('takes screenshot without async-await', function (browser) {
browser.waitForElementVisible('body');
const heading = browser.element('.hero__heading');
const screenshot = heading.takeScreenshot();
screenshot.then((screenshotData) => {
require('fs').writeFile('heading.png', screenshotData, 'base64', (err) => {
browser.assert.strictEqual(err, null);
});
});
});
it('takes screenshot with async-await', async function (browser) {
browser.waitForElementVisible('body');
const heading = browser.element('.hero__heading');
const screenshotData = await heading.takeScreenshot();
require('fs').writeFile('heading1.png', screenshotData, 'base64', (err) => {
browser.assert.strictEqual(err, null);
});
});
after((browser) => browser.end());
});
================================================
FILE: examples/tests/element/elementapi-tests.js
================================================
describe('queries tests', function() {
beforeEach(function(browser) {
browser.navigateTo('http://localhost:13370');
});
it('getFirstElementChild', async function({element}) {
const firstChild = await element.find('#nested').getFirstElementChild().inspectInDevTools('firstChild');
await expect(firstChild).to.be.an('h3');
const lastChild = await element('#nested').getLastElementChild().inspectInDevTools('lastChild');
const nextElementSibling = await element('#nested').getNextElementSibling().inspectInDevTools('nextElementSibling');
const previousElementSibling = await element('#nested').inspectInDevTools('previousElementSibling');
});
it('assert.present', async function({element}) {
await element.findAll('section').nth(1).assert.present();
});
it('assert.hasAttribute', async function({element}) {
await element.findAll('section').nth(1).find('button').assert.hasAttribute('role');
});
it('custom element assertion', async function({element}) {
await element.findAll('section').nth(1).find('button').assert.customScript(function(element, content) {
return element.innerHTML === content;
}, ['Unique Button Text'], 'Custom assertion message: button has correct text');
});
it('findByRole', async function({element}) {
const button = await element.findAll('section').nth(1).findByRole('button');
await expect(button).to.be.an('button');
await browser.click(button);
await expect(button).text.to.equal('Button Clicked');
});
it('findAll', async function({element}) {
await element.findAll('section').count().assert.equals(9);
});
it('Button click works', async function(browser) {
const button = await browser.element.findByText('Unique Button Text');
await expect(button).text.not.to.equal('Button Clicked');
await browser.click(button);
await expect(button).text.to.equal('Button Clicked');
});
it('findByPlaceholderText', async function ({element, actions}) {
const input = await element.findByPlaceholderText('Placeholder Text').assert.visible('Input is visible');
await expect(input).property('value').not.to.equal('Hello Placeholder');
// // Uses the User Actions API to type into the input
await actions().sendKeys(input, 'Hello Placeholder').perform();
await expect(input).property('value').to.equal('Hello Placeholder');
});
it('findByLabelText', async function ({element}) {
const input = await element.findByLabelText('Label For Input Labelled By Id').sendKeys('Hello Input Labelled by Id');
expect(input).value.toEqual('Hello Input Labelled by Id');
});
it('findByAltText', async function ({element}) {
const image = await element.findByAltText('Image Alt Text').click();
expect(image).css('border').toEqual('5px solid rgb(255, 0, 0)');
});
it('findAllByText', async function ({element}) {
const philosophers = await element.findAllByText('of Miletus', {exact: false});
expect(philosophers).to.have.length(2);
});
});
================================================
FILE: examples/tests/element/isCommands.js
================================================
describe('Element "is" commands Demo', function () {
before((browser) => {
browser.navigateTo('https://www.ecosia.org/settings');
});
it('Demo', async function (browser) {
// accepting cookies to remove modal
browser.element('.cookie-consent__actions').getLastElementChild().click();
const saveButton = browser.element('.settings-form__buttons > .base-button--variant-solid-green');
const cancelButton = browser.element('.settings-form__buttons > .base-button--variant-outline');
saveButton.isVisible().assert.equals(true);
cancelButton.isVisible().assert.equals(true);
saveButton.isEnabled().assert.equals(false);
cancelButton.isEnabled().assert.equals(true);
const newTabCheckbox = browser.element('#e-field-newTab');
newTabCheckbox.isSelected().assert.equals(false);
// Clicking the checkbox selects it.
// Also our save button becomes enabled.
newTabCheckbox.click();
newTabCheckbox.isSelected().assert.equals(true);
saveButton.isEnabled().assert.equals(true);
// click the cancel button
cancelButton.click();
});
after((browser) => browser.end());
});
================================================
FILE: examples/tests/google.js
================================================
describe('sample google search', function() {
this.tags = ['google'];
it('demo test using expect apis', async function(browser) {
await browser.navigateTo('http://google.no');
const consentPresent = await browser.isPresent('[aria-modal="true"][title="Before you continue to Google Search"]');
// Wait until we are on consent page
if (consentPresent === true) {
browser
.waitForElementVisible('[aria-modal="true"][title="Before you continue to Google Search"]')
.click('[aria-modal="true"] div.VDity button:nth-child(1)')
// Wait until we are on consent page
.expect.url().toContain('https://consent.google.no')
// Turn everything off
.click('button[aria-label="Turn off Search customization"]')
.click('button[aria-label="Turn off YouTube History"]')
.click('button[aria-label="Turn off Ad personalization"]')
// click on confirm button
.click('form[action^="https://consent.google.no"] button')
// saving the consent form takes some time, no need to check for anything else
.pause(1000);
}
let locator;
if (browser.isMobile()) {
locator = 'form[action="/search"] input[type=search]';
} else {
locator = 'form[action="/search"] input[type=text]';
}
await browser
.waitForElementVisible(locator)
.sendKeys(locator, ['Nightwatch.js', browser.Keys.ENTER])
.assert.textContains('#rso>:first-child', 'Nightwatch.js')
.end();
});
});
================================================
FILE: examples/tests/googlePageObject.js
================================================
describe('google search with consent form - page objects', function() {
const homePage = browser.page.google.search();
before(async () => homePage.navigate());
after(async (browser) => browser.quit());
it('should find nightwatch.js in results', function (browser) {
homePage.setValue('@searchBar', 'Nightwatch.js');
homePage.submit();
const resultsPage = browser.page.google.searchResults();
resultsPage.expect.element('@results').to.be.present;
resultsPage.expect.element('@results').text.to.contain('Nightwatch.js');
resultsPage.expect.section('@menu').to.be.visible;
const menuSection = resultsPage.section.menu;
menuSection.expect.element('@videos').to.be.visible;
});
});
================================================
FILE: examples/tests/sample-with-relative-locators.js
================================================
/* eslint-disable no-undef */
describe('sample with relative locators', function () {
before(browser => browser.navigateTo('https://archive.org/account/login'));
it('locate password input', function (browser) {
const passwordElement = locateWith(By.tagName('input')).below(By.css('input[type=email]'));
browser
.waitForElementVisible(passwordElement)
.expect.element(passwordElement).to.be.an('input');
browser.expect.element(passwordElement).attribute('type').equal('password');
});
it('fill in password input', function (browser) {
const passwordElement = locateWith(By.tagName('input')).below(By.css('input[type=email]'));
browser
.waitForElementVisible('form.login-form')
.setValue(passwordElement, 'password')
.assert.valueEquals('input[type=password]', 'password');
});
after(browser => browser.end());
});
================================================
FILE: examples/tests/selectElement.js
================================================
const {Select} = require('selenium-webdriver');
module.exports = {
before(browser) {
browser.url('https://www.selenium.dev/selenium/web/formPage.html');
},
async demoTest(browser) {
const selectElement = browser.element('select[name=selectomatic]');
await browser
.perform(async function() {
const selectWebElement = await selectElement; // `Select` class expects a WebElement
const select = new Select(selectWebElement);
await select.selectByVisibleText('Four');
})
.assert.selected(await selectElement.findElement('option[value=four]'), 'Forth option is selected');
}
};
================================================
FILE: examples/tests/shadowRootExample.js
================================================
describe('Shadow Root example test', function() {
it('retrieve the shadowRoot', async function(browser) {
browser
.navigateTo('https://mdn.github.io/web-components-examples/popup-info-box-web-component/')
.waitForElementVisible('form');
// const shadowId = browser.element('popup-info').getId().map(val => {
// return val + 'shadow';
// }).assert.contains('shadow');
// console.log('!!! shadowId', shadowId)
// const elForm = await browser.element.findAllByText('Pop-up info widget', {exact: false}).nth(0);
// expect(elForm).to.be.a('h1');
// const elForm = await browser.element.findAll('form').nth(0);
// expect(elForm).to.be.a('form');
// const formCount = await browser.element.findAll('form').count();
// expect(formCount).to.equal(1);
//
// const elInput = await browser.element.find('form').find('input');
// console.log('!!! elInput', elInput);
//expect(elInput).to.be.an('input');
// const els = await browser.element.findAll('form').count();
// console.log('!!! els', els);
//
// //await expect(shadowId).to.be.a('string').and.to.include('shadow')
//
// no `await` used since `shadowRootEl` is going to be chained further
const shadowRootEl = browser.element('popup-info').getShadowRoot();
const infoElement = shadowRootEl.find('.info').property('innerHTML');
//
// //console.log('!!! infoElement', infoElement.assert)
//
// expect(infoElement)
// .to.be.a('string')
// .and.to.include('card validation code');
//
// const iconElement = await shadowRootEl.find('.icon');
// console.log('!!! iconElement', iconElement)
//
// const firstElement = await browser.getFirstElementChild(iconElement);
//
// await expect.element(firstElement).to.be.an('img');
});
});
================================================
FILE: examples/tests/vueTodoList.js
================================================
/**
* End-to-end test for the sample Vue3+Vite todo app located at
* https://github.com/nightwatchjs-community/todo-vue
*/
describe('To-Do List End-to-End Test', function() {
// using the new element() global utility in Nightwatch 2 to init elements
// before tests and use them later
const todoElement = element('#new-todo-input');
const addButtonEl = element('form button[type="submit"]');
it('should add a todo using global element()', async function() {
///////////////////////////////////////////////////
// browser can now also be accessed as a global |
///////////////////////////////////////////////////
// adding a new task to the list
await browser
.navigateTo('https://todo-vue3-vite.netlify.app/')
.sendKeys(todoElement, 'what is nightwatch?')
.click(addButtonEl);
///////////////////////////////////////////////////
// global expect is equivalent to browser.expect |
///////////////////////////////////////////////////
// verifying if there are 5 tasks in the list
await expect.elements('#todo-list ul li').count.toEqual(5);
// verifying if the 4th task if the one we have just added
const lastElementTask = element({
selector: '#todo-list ul li',
index: 4
});
await expect(lastElementTask).text.toContain('what is nightwatch?');
// find our task in the list and mark it as done
const inputElement = await lastElementTask.findElement('input[type="checkbox"]');
await browser.click(inputElement);
// verify if there are 3 tasks which are marked as done in the list
await expect.elements('#todo-list ul li input:checked').count.toEqual(3);
});
});
================================================
FILE: examples/tsconfig.json
================================================
{
"extends": "../tsconfig",
"include": ["."]
}
================================================
FILE: examples/unittests/demoTestAsync.js
================================================
const assert = require('assert');
module.exports = {
'@unitTest': true,
'demo UnitTest': function (done) {
assert.strictEqual('TEST', 'TEST');
setTimeout(function() {
done();
}, 10);
}
};
================================================
FILE: examples/unittests/testUtils.js
================================================
const assert = require('assert');
const Utils = require('../../dist/utils/');
module.exports = {
testFormatElapsedTime: function() {
var resultMs = Utils.formatElapsedTime(999);
assert.strictEqual(resultMs, '999ms');
var resultSec = Utils.formatElapsedTime(1999);
assert.strictEqual(resultSec, '1.999s');
var resultMin = Utils.formatElapsedTime(122299, true);
assert.strictEqual(resultMin, '2m 2s / 122299ms');
},
testGetTestSuiteName: function() {
assert.strictEqual(Utils.getTestSuiteName('test-case-one'), 'Test Case One');
assert.strictEqual(Utils.getTestSuiteName('test_case_two'), 'Test Case Two');
assert.strictEqual(Utils.getTestSuiteName('test.case.one'), 'Test Case One');
assert.strictEqual(Utils.getTestSuiteName('testCaseOne'), 'Test Case One');
}
};
================================================
FILE: examples/unittests/testUtilsWithChai.js
================================================
const Utils = require('../../dist/utils/');
const expect = require('chai').expect;
module.exports = {
testFormatElapsedTime: function() {
var resultMs = Utils.formatElapsedTime(999);
var resultSec = Utils.formatElapsedTime(1999);
var resultMin = Utils.formatElapsedTime(122299, true);
expect(resultMs).to.equal('999ms');
expect(resultSec).to.equal('1.999s');
expect(resultMin).to.equal('2m 2s / 122299ms');
},
testFormatElapsedTimeMore: function() {
var resultMs = Utils.formatElapsedTime(999);
expect(resultMs).to.equal('999ms');
}
};
================================================
FILE: index.js
================================================
module.exports = process.env.NIGHTWATCH_COV ?
require('./lib-cov/index') :
require('./lib/index');
================================================
FILE: lib/api/_loaders/_base-loader.js
================================================
const path = require('path');
const fs = require('fs');
const EventEmitter = require('events');
const Utils = require('../../utils');
const namespacedApi = require('../../core/namespaced-api.js');
const ScopedElementAPILoader = require('./element-api.js');
let __last_deferred__ = null;
class BaseLoader extends EventEmitter {
static get commandOverrides () {
return {
element(nightwatchInstance, ...args) {
if (nightwatchInstance.settings.backwards_compatibility_mode) {
return args[0];
}
return new ScopedElementAPILoader(nightwatchInstance).createElementMethod();
}
};
}
static handleModuleError(err, fullPath) {
const {message} = err;
const showStackTrace = ['SyntaxError', 'TypeError'].includes(err.name);
const error = new Error(`There was an error while trying to load the file ${fullPath}:`);
error.detailedErr = `[${err.code || err.name}] ${message};`;
error.extraDetail = `\n Current working directory is: ${process.cwd()}`;
error.showTrace = showStackTrace;
error.displayed = false;
if (showStackTrace) {
error.stack = err.stack;
}
throw error;
}
static unflattenNamespace(target, namespace, value) {
const key = namespace.shift();
if (key) {
target[key] = target[key] || {};
value = target[key];
return BaseLoader.unflattenNamespace(target[key], namespace, value);
}
return value;
}
static createDriverCommand(nightwatchInstance, commandName) {
return function commandFn({args}) {
return nightwatchInstance.transport.driver[commandName](...args).catch((error) => {
if (error.remoteStacktrace) {
delete error.remoteStacktrace;
}
return {
value: null,
error
};
});
};
}
static get lastDeferred() {
return __last_deferred__;
}
static set lastDeferred(value) {
__last_deferred__ = value;
}
get commandQueue() {
return this.nightwatchInstance.queue;
}
get loadSubDirectories() {
return false;
}
get reporter() {
return this.nightwatchInstance.reporter;
}
get api() {
return this.nightwatchInstance.api;
}
get elementLocator() {
return this.nightwatchInstance.elementLocator;
}
get transport() {
return this.nightwatchInstance.transport;
}
get namespace() {
return this.__namespace;
}
get module() {
return this.__module;
}
set module(val) {
this.__module = val;
}
get commandName() {
return this.__commandName;
}
get commandFn() {
return this.__commandFn;
}
set commandFn(val) {
this.__commandFn = val;
}
set commandName(val) {
this.__commandName = val;
}
set stackTrace(val) {
this.__stackTrace = val;
}
get stackTrace() {
return this.__stackTrace;
}
get instance() {
return this.__instance;
}
get isUserDefined() {
return this.__isUserDefined;
}
set isUserDefined(val) {
this.__isUserDefined = val;
}
get addedInsideCallback() {
return this.__addedInsideCallback;
}
set addedInsideCallback(val) {
this.__addedInsideCallback = val;
}
set ignoreUnderscoreLeadingNames(val) {
this.__ignoreUnderscoreNames = val;
}
get ignoreUnderscoreLeadingNames() {
return this.__ignoreUnderscoreNames && !this.isUserDefined;
}
constructor(nightwatchInstance) {
super();
BaseLoader.lastDeferred = null;
this.nightwatchInstance = nightwatchInstance;
}
isTypescriptDisabled() {
return this.nightwatchInstance.settings.disable_typescript;
}
get settings() {
return this.nightwatchInstance.settings;
}
getTargetNamespace() {
return null;
}
isFileNameValid(fileName) {
if (fileName.startsWith('_') && this.ignoreUnderscoreLeadingNames) {
return false;
}
return Utils.isFileNameValid(fileName);
}
setNamespace(val) {
this.__namespace = val;
return this;
}
loadModule(dirPath, fileName) {
const fullPath = path.join(dirPath, fileName);
if (!this.loadSubDirectories && fs.lstatSync(fullPath).isDirectory()) {
return this;
}
this.requireModule(fullPath, fileName);
return this;
}
requireModule(fullPath, fileName) {
if (!this.isFileNameValid(fileName)) {
return this;
}
if (this.isTypescriptDisabled() && Utils.isTsFile(fileName)) {
return this;
}
this.commandName = path.parse(fullPath).name;
this.fileName = fullPath;
try {
this.module = Utils.requireModule(fullPath);
} catch (err) {
BaseLoader.handleModuleError(err, fullPath);
}
}
async loadModuleAsync(dirPath, fileName) {
const fullPath = path.join(dirPath, fileName);
if (!this.loadSubDirectories && fs.lstatSync(fullPath).isDirectory()) {
return this;
}
await this.requireModuleAsync(fullPath, fileName);
}
async requireModuleAsync(fullPath, fileName) {
if (!this.isFileNameValid(fileName)) {
return this;
}
if (this.isTypescriptDisabled() && Utils.isTsFile(fileName)) {
return this;
}
this.commandName = path.parse(fullPath).name;
this.fileName = fullPath;
try {
this.module = await Utils.requireModule(fullPath);
} catch (err) {
BaseLoader.handleModuleError(err, fullPath);
}
}
validateMethod() {}
defineArgs(parent, namespacedApi) {
const {commandName} = this;
const commandFn = this.commandFn.bind(this);
let stringifiedNamespace;
let mainNamespace;
let apiToReturn;
if (this.namespace && Utils.isString(this.namespace)) {
stringifiedNamespace = this.namespace;
mainNamespace = this.namespace;
} else if (Array.isArray(this.namespace) && this.namespace.length > 0) {
stringifiedNamespace = this.namespace.join('.');
mainNamespace = this.namespace[0];
}
if (namespacedApi && mainNamespace) {
namespacedApi[mainNamespace] = namespacedApi[mainNamespace] || {};
apiToReturn = new Proxy(namespacedApi[mainNamespace], {
get(_, name) {
// namespacedApi[mainNamespace] may change after API loading is finished.
return namespacedApi[mainNamespace][name];
}
});
} else if (parent && parent.__is_page_object_cache) {
// commands loaded onto a page object should return the page object only.
apiToReturn = parent;
}
const args = [
this.createQueuedCommandFn({
parent,
commandName,
namespace: stringifiedNamespace,
commandFn,
apiToReturn,
context: this
})
];
// Define the element method as a namespace.
if (commandName in BaseLoader.commandOverrides) {
args[0] = BaseLoader.commandOverrides[commandName](this.nightwatchInstance, ...args);
}
const namespace = this.getTargetNamespace(parent, namespacedApi);
if (namespace) {
args.unshift(namespace);
}
return args;
}
getNamespacedAliases() {
const nsAliases = this.module && this.module.namespacedAliases;
if (nsAliases && Utils.isString(nsAliases)) {
return [nsAliases.split('.')];
}
if (Array.isArray(nsAliases)) {
return nsAliases
.filter((nsAlias) => nsAlias && Utils.isString(nsAlias))
.map((nsAlias) => nsAlias.split('.'));
}
return [];
}
define(parent = null) {
if (!this.commandFn) {
return this;
}
const {commandName, namespace, nightwatchInstance} = this;
this.validateMethod(parent);
const args = this.defineArgs(parent);
nightwatchInstance.setApiMethod(commandName, ...args);
// check for namespaced aliases
const nsAliases = this.getNamespacedAliases();
nsAliases.forEach((ns) => {
this.commandName = ns.pop();
this.setNamespace(ns);
this.validateMethod(parent);
const args = this.defineArgs(parent);
nightwatchInstance.setApiMethod(this.commandName, ...args);
});
this.commandName = commandName;
this.setNamespace(namespace);
return this.defineNamespacedApi(parent, namespacedApi);
}
defineNamespacedApi(parent) {
// namespaced api would have already been loaded as named exports (without parent),
// do not load commands again for parent (page-objects or within-context).
if (parent || !this.commandFn) {
return this;
}
const {commandName, namespace, nightwatchInstance} = this;
if (this.namespace && this.namespace.length) {
const args = this.defineArgs(parent, namespacedApi);
nightwatchInstance.setNamespacedApiMethod(commandName, ...args);
}
// check for namespaced aliases
const nsAliases = this.getNamespacedAliases();
nsAliases.forEach((ns) => {
this.commandName = ns.pop();
if (ns.length) {
this.setNamespace(ns);
const args = this.defineArgs(parent, namespacedApi);
nightwatchInstance.setNamespacedApiMethod(this.commandName, ...args);
}
});
this.commandName = commandName;
this.setNamespace(namespace);
return this;
}
getCommandOptions() {
return {};
}
createQueuedCommandFn({parent, commandName, namespace, commandFn, context, apiToReturn}) {
const {commandQueue, api, nightwatchInstance} = this;
return function queuedCommandFn(...args) {
const stackTrace = Utils.getOriginalStackTrace(queuedCommandFn);
const deferred = Utils.createPromise();
deferred.commandName = commandName;
// if this command was called from another async (custom) command
const isAsyncCommand = this.isES6Async;
const options = this.getCommandOptions();
if (args && args.length > 0 && Utils.isFunction(args[args.length - 1])) {
const callback = args.pop();
const userCallbackWrapper = (function(context) {
const proxyFn = new Proxy(callback, {
apply: function(target, thisArg, argumentsList) {
context.addedInsideCallback = true;
return target.apply(thisArg, argumentsList);
}
});
proxyFn.originalTarget = callback;
return proxyFn;
})(this);
args.push(userCallbackWrapper);
}
// if this command was called from an async test case
let isES6Async = options.alwaysAsync || nightwatchInstance.settings.always_async_commands;
if (!isES6Async) {
isES6Async = Utils.isUndefined(this.isES6Async) ? (
nightwatchInstance.isES6AsyncTestcase || nightwatchInstance.isES6AsyncCommand
) : isAsyncCommand;
}
if (!Utils.isUndefined(nightwatchInstance.isES6AsyncTestHook)) {
isES6Async = nightwatchInstance.isES6AsyncTestHook;
}
const node = commandQueue.add({
commandName,
commandFn,
context: this,
args,
stackTrace,
namespace,
options,
deferred,
isES6Async
});
if (this.module && this.module.autoInvoke) {
const result = node.execute(true);
return result;
}
if (isES6Async || options.alwaysAsync || node.isES6Async) {
BaseLoader.lastDeferred = node.deferred;
if (parent && parent.__pageObjectItem__) {
// never seem to reach here, because page-object commands are loaded
// in the starting itself before the actual page-objects are loaded,
// so `parent` here represents `__page_object_cache` and not the actual
// page on which command is being run.
Object.assign(node.deferred.promise, parent.__pageObjectItem__);
} else {
Object.assign(node.deferred.promise, apiToReturn || api);
}
//prevent unhandled rejection.
node.deferred.promise.catch(err => {
if (BaseLoader.lastDeferred) {
// TODO: check in what cases BaseLoader.lastDeferred could be set to null
// in between the execution of the test.
// issue: #4265; hint: could have something to do with custom commands.
BaseLoader.lastDeferred.reject(err);
}
});
if (!this.module?.returnFn) {
return node.deferred.promise;
}
}
if (this.module?.returnFn) {
return this.module.returnFn(node, apiToReturn || api);
}
return apiToReturn || api;
}.bind(context);
}
loadDriverCommands({commands, namespace}) {
commands.forEach(propertyName => {
const commandFn = BaseLoader.createDriverCommand(this, propertyName);
this.nightwatchInstance.setApiMethod(propertyName, namespace, (function (commandName) {
return this.createQueuedCommandFn({
commandName,
commandFn,
context: this,
namespace
});
}.bind(this))(propertyName));
// Add command to namespaced-api as well
namespacedApi[namespace] = namespacedApi[namespace] || {};
this.nightwatchInstance.setNamespacedApiMethod(propertyName, namespace, (function (commandName) {
return this.createQueuedCommandFn({
commandName,
commandFn,
context: this,
namespace,
apiToReturn: namespacedApi[namespace]
});
}.bind(this))(propertyName));
});
}
}
module.exports = BaseLoader;
================================================
FILE: lib/api/_loaders/_command-loader.js
================================================
const Element = require('../../element');
const BaseLoader = require('./_base-loader.js');
class BaseCommandLoader extends BaseLoader {
constructor(nightwatchInstance) {
super(nightwatchInstance);
this.type = 'command';
this.__namespace = null;
this.__module = null;
this.__commandName = null;
this.__commandFn = null;
this.__instance = null;
this.__isUserDefined = false;
this.ignoreUnderscoreLeadingNames = true;
}
static isTypeImplemented(instance, method, type) {
const methodTypes = method.split('|');
if (type === '*') {
return instance[method] !== undefined;
}
return methodTypes.some(method => (typeof instance[method] == type));
}
get sessionId() {
return this.nightwatchInstance.session.sessionId;
}
getCommandOptions() {
const redact = this.module.RedactParams || false;
const alwaysAsync = this.module.alwaysAsync || false;
const isTraceable = this.module.isTraceable;
const avoidPrematureParentNodeResolution = !!this.module.avoidPrematureParentNodeResolution;
const rejectNodeOnAbortFailure = !!this.module.rejectNodeOnAbortFailure;
return {redact, alwaysAsync, isTraceable, avoidPrematureParentNodeResolution, rejectNodeOnAbortFailure};
}
validateMethod(parent) {
let namespace = this.getTargetNamespace(parent);
if (Array.isArray(namespace) && namespace.length > 0) {
namespace = BaseLoader.unflattenNamespace(this.api, namespace.slice());
}
if (this.module.allowOverride) {
this.nightwatchInstance.overridableCommands.add(this.commandName);
}
if (this.nightwatchInstance.isApiMethodDefined(this.commandName, namespace) && !this.nightwatchInstance.overridableCommands.has(this.commandName)) {
const err = new TypeError(`Error while loading the API commands: the ${this.type} ${this.namespace || ''}.${this.commandName}() is already defined.`);
err.displayed = false;
err.detailedErr = `Source: ${this.fileName}`;
err.showTrace = false;
throw err;
}
return this;
}
resolveElementSelector(args) {
if ((args[0] instanceof Element) && this.isUserDefined) {
const element = args[0];
if (element.usingRecursion) {
return this.elementLocator.resolveElementRecursively({element});
}
return Promise.resolve(element);
}
return Promise.resolve();
}
getTargetNamespace(parent) {
const namespace = this.namespace;
if (!parent) {
return namespace;
}
if (!namespace || namespace.length === 0) {
return parent;
}
// would give unexpected results if command with nested namespaces
// is loaded onto say page-object (but wouldn't throw an error)
parent[namespace] = parent[namespace] || {};
return parent[namespace];
}
}
module.exports = BaseCommandLoader;
================================================
FILE: lib/api/_loaders/assertion-scheduler.js
================================================
const Utils = require('../../utils');
const Element = require('../../element');
const {AssertionRunner} = require('../../assertion');
const {Logger} = Utils;
class AssertionScheduler {
get instance() {
return this.__instance;
}
get opts() {
return this.__opts;
}
/**
* @param {AssertionInstance} instance
* @param {{rescheduleInterval, abortOnFailure, stackTrace, timeout, reporter}} opts
*/
constructor(instance, opts = {}) {
this.__instance = instance;
this.__opts = opts;
this.retries = 0;
this.deferred = Utils.createPromise();
this.shouldRetry = this.opts.timeout > 0;
this.setOptsFromSelector();
}
reschedule() {
setTimeout(() => {
this.retries++;
this.schedule();
}, this.opts.rescheduleInterval);
}
setOptsFromSelector() {
if (this.instance.element instanceof Element) {
const {timeout, retryInterval} = this.instance.element;
if (!Utils.isUndefined(timeout)) {
this.__opts.timeout = timeout;
}
if (!Utils.isUndefined(retryInterval)) {
this.__opts.rescheduleInterval = retryInterval;
}
}
}
createAssertionRunner({passed, actual, commandCallback, message, elapsedTime}) {
const expected = Utils.isFunction(this.instance.expected) ? this.instance.expected() : this.instance.expected;
const {abortOnFailure, stackTrace, reporter} = this.opts;
this.runner = new AssertionRunner({
passed, err: {
expected,
actual
},
calleeFn: commandCallback,
message,
abortOnFailure,
stackTrace,
reporter,
elapsedTime
});
}
verifyCommandArgs() {
if (this.instance.command.length === 0) {
throw new Error(`Assertion "command" methods require one "callback" parameter. Check the command method in: ${this.instance.fileName}.`);
}
return this;
}
start() {
this.startTime = new Date().getTime();
this.schedule();
return this.deferred.promise;
}
schedule() {
this.instance.command(function commandCallback(commandResult, commandInstance) {
const {instance, startTime} = this;
const elapsedTime = new Date().getTime() - startTime;
if (commandInstance) {
//this.__opts.abortOnFailure = commandInstance.abortOnFailure;
}
let passed;
let value;
instance.elapsedTime = elapsedTime;
instance.setResult(commandResult);
if (instance.hasFailure()) {
passed = false;
value = null;
} else {
value = instance.getValue();
passed = instance.isOk(value);
}
if (!passed && elapsedTime < this.opts.timeout) {
this.reschedule();
return null;
}
if (instance.refineFormattedMessage) {
// For new generic assertions we have to create message after the actual
// value is resolved. Unfortunately the main formatMessage method cannot be
// asynchronous.
// I have no idea why assertion message is created before the assertion happens
// or at least actual value is resolved O_o
instance.refineFormattedMessage(value);
}
const message = this.getFullMessage(passed, elapsedTime);
const actual = instance.getActual();
this.createAssertionRunner({passed, actual, commandCallback, message, elapsedTime});
// FIXME: Returning the promise here in the event the it's needed in the assertion callback,
// throws an unhandledRejection when using es6 async because there's no catch in the assertion callback
// - adding the catch should be done when breaking changes are going to be introduced.
let resolveValue = {};
let testError;
if (commandResult && commandResult.error instanceof Error) {
testError = commandResult.error;
}
return this.runner
.run(commandResult)
.then(result => {
resolveValue = Object.assign(resolveValue, result);
resolveValue.passed = true;
})
.catch(err => {
resolveValue.passed = false;
resolveValue.err = err;
return err;
})
.then(() => {
Utils.makePromise(this.instance.doneCallback, this, [resolveValue, this.instance]);
})
.then(_ => {
if (testError && testError.name !== 'NoSuchElementError') {
this.opts.reporter.registerTestError(testError);
}
setTimeout(()=> {
if (resolveValue.passed) {
this.deferred.resolve(resolveValue);
} else {
this.deferred.reject(resolveValue.err);
}
});
});
}.bind(this), this.instance);
}
getFullMessage(passed, elapsedTime) {
if (!this.shouldRetry) {
return this.instance.message;
}
let timeLogged = passed ? elapsedTime : this.opts.timeout;
if (this.instance.message.endsWith('.')) {
this.instance.message = this.instance.message.substr(0, this.instance.message.length - 1);
}
return `${this.instance.message} ${(passed ? Logger.colors.stack_trace(`(${timeLogged}ms)`) : `in ${timeLogged}ms`)}`;
}
}
module.exports.create = function(instance, opts) {
const scheduler = new AssertionScheduler(instance, opts);
scheduler.verifyCommandArgs();
return scheduler.start();
};
================================================
FILE: lib/api/_loaders/assertion.js
================================================
const {WebElementPromise} = require('selenium-webdriver');
const BaseCommandLoader = require('./_command-loader.js');
const Utils = require('../../utils');
const AssertionInstance = require('../assertions/_assertionInstance.js');
const Scheduler = require('./assertion-scheduler.js');
class AssertionLoader extends BaseCommandLoader {
static get interfaceMethods() {
return {
expected: '*',
'pass|evaluate': 'function',
command: 'function'
};
}
static validateAssertClass(instance) {
Object.keys(AssertionLoader.interfaceMethods).forEach(method => {
const type = AssertionLoader.interfaceMethods[method];
if (!BaseCommandLoader.isTypeImplemented(instance, method, type)) {
const methodTypes = method.split('|').map(name => `"${name}"`);
throw new Error(`Assertion class must implement method/property ${methodTypes.join(' or ')}`);
}
});
}
constructor(nightwatchInstance) {
super(nightwatchInstance);
AssertionLoader.lastDeferred = null;
this.type = 'assertion';
this.abortOnFailure = this.globals.abortOnAssertionFailure;
}
get timeout() {
return this.globals.retryAssertionTimeout;
}
get rescheduleInterval() {
return this.globals.waitForConditionPollInterval;
}
get globals() {
return this.api.globals;
}
containsES6Class() {
return this.module.prototype && this.module.prototype.constructor.toString().startsWith('class');
}
validateModuleDefinition() {
if (this.containsES6Class()) {
return this.validateES6Class();
}
return this.validateCJSModule();
}
validateCJSModule() {
if (!(Utils.isObject(this.module) && this.module.assertion)) {
throw new Error('The assertion module needs to contain an .assertion() method');
}
}
validateES6Class() {
if (!this.module.prototype.command) {
throw new Error('Assertion class must implement an command() method');
}
}
createQueuedCommandFn({parent, apiToReturn}) {
const commandFn = this.commandFn.bind(this);
const {commandQueue, commandName, namespace, api, nightwatchInstance} = this;
return function queuedCommandFn({negate, args}) {
const stackTrace = Utils.getOriginalStackTrace(queuedCommandFn);
// we only should return a Promise if not a nightwatch element, otherwise we risk breaking changes
const element = args[0];
const shouldReturnPromise = element && !(element instanceof WebElementPromise) && (element.sessionId && element.elementId || element.driver_ && element.id_);
const deferred = Utils.createPromise();
const isES6Async = shouldReturnPromise || nightwatchInstance.settings.always_async_commands ||
(Utils.isUndefined(this.isES6Async) ? nightwatchInstance.isES6AsyncTestcase : this.isES6Async);
const node = commandQueue.add({
commandName,
commandFn,
context: this,
args,
options: {
negate
},
stackTrace,
namespace,
deferred,
isES6Async
});
if (isES6Async) {
AssertionLoader.lastDeferred = deferred;
commandQueue.tree.once('asynctree:finished', (err) => {
node.deferred.resolve(node.resolveValue);
});
if (parent && parent.__pageObjectItem__) {
Object.assign(node.deferred.promise, parent.__pageObjectItem__);
} else {
Object.assign(node.deferred.promise, apiToReturn || api);
}
// prevent unhandledRejection errors
node.deferred.promise.catch(err => {
// null check, as done for BaseLoader.lastDeferred as well.
if (AssertionLoader.lastDeferred) {
return AssertionLoader.lastDeferred.reject(err);
}
});
return node.deferred.promise;
}
return apiToReturn || api;
}.bind(this);
}
createWrapper(abortOnFailure) {
if (this.module) {
this.validateModuleDefinition();
this.abortOnFailure = abortOnFailure;
this.commandFn = function commandFn({args, stackTrace, options}) {
return this.resolveElementSelector(args)
.then(elementResult => {
if (elementResult) {
args[0] = elementResult;
}
const {nightwatchInstance, reporter, abortOnFailure, module, fileName} = this;
const instance = AssertionInstance.create({
nightwatchInstance,
assertionModule: module,
fileName,
args,
options
});
AssertionLoader.validateAssertClass(instance);
this.__instance = instance;
return Scheduler.create(instance, {
stackTrace,
rescheduleInterval: Utils.isNumber(instance.rescheduleInterval) ? instance.rescheduleInterval : this.rescheduleInterval,
timeout: Utils.isNumber(instance.retryAssertionTimeout) ? instance.retryAssertionTimeout : this.timeout,
abortOnFailure,
reporter
});
});
};
}
return this;
}
}
module.exports = AssertionLoader;
================================================
FILE: lib/api/_loaders/chrome.js
================================================
const BaseLoader = require('./_base-loader.js');
class ChromeCommandLoader extends BaseLoader {
static get chromeCommands() {
return [
'launchApp',
'getNetworkConditions',
'setNetworkConditions',
'deleteNetworkConditions',
'sendDevToolsCommand',
'sendAndGetDevToolsCommand',
'setPermission',
'setDownloadPath',
'getCastSinks',
'setCastSinkToUse',
'startCastTabMirroring',
'getCastIssueMessage',
'stopCasting'
];
}
loadCommands() {
const commands = ChromeCommandLoader.chromeCommands;
this.loadDriverCommands({
commands,
namespace: 'chrome'
});
return this;
}
}
module.exports = ChromeCommandLoader;
================================================
FILE: lib/api/_loaders/command.js
================================================
const EventEmitter = require('events');
const BaseCommandLoader = require('./_command-loader.js');
const {Logger, isES6AsyncFn, isFunction, isObject, makePromise} = require('../../utils');
class CommandLoader extends BaseCommandLoader {
static get interfaceMethods() {
return {
command: 'function'
};
}
static isDeprecatedCommandStyle(CommandModule) {
return isObject(CommandModule) && isFunction(CommandModule.command);
}
/**
* This is to support backwards-compatibility for commands defined as objects,
* with a command() property
*
* @param CommandModule
*/
static createFromObject(CommandModule) {
return class CommandClass extends EventEmitter {
command(...args) {
if (isES6AsyncFn(CommandModule.command)) {
return CommandModule.command.apply(this.api, args);
}
setImmediate(() => {
CommandModule.command.apply(this.api, args);
});
return this.api;
}
};
}
static transportActions({actions, api}) {
return new Proxy(actions, {
get(target, name) {
return function(...args) {
let callback;
let method;
const isLastArgFunction = isFunction(args[args.length - 1]);
if (isLastArgFunction) {
callback = args.pop();
} else if (args.length === 0 || !isLastArgFunction) {
callback = function(result) {return result};
}
const definition = {
args
};
if (name in target.session) { // actions that require the current session
method = target.session[name];
definition.sessionId = api.sessionId;
} else {
method = target[name];
}
return method(definition).then((result) => makePromise(callback, api, [result]));
};
}
});
}
static createInstance(nightwatchInstance, CommandModule, opts) {
const CommandClass = CommandLoader.isDeprecatedCommandStyle(CommandModule) ? CommandLoader.createFromObject(CommandModule) : CommandModule;
class CommandInstance extends CommandClass {
reportProtocolErrors(result) {
if (opts.isUserDefined) {
return true;
}
return super.reportProtocolErrors(result);
}
get api() {
return nightwatchInstance.api;
}
get reuseBrowser() {
return nightwatchInstance.argv['reuse-browser'] || (nightwatchInstance.settings.globals && nightwatchInstance.settings.globals.reuseBrowserSession);
}
get isES6AsyncCommand() {
return isES6AsyncFn(
CommandLoader.isDeprecatedCommandStyle(CommandModule) ? CommandModule.command : this.command
);
}
get client() {
return this.__nightwatchInstance || nightwatchInstance;
}
get commandFileName() {
return opts.commandName;
}
get commandArgs() {
return opts.args;
}
get transportActions() {
return this.client.transportActions;
}
get driver() {
return this.client.transport.driver;
}
httpRequest(requestOptions) {
return this.client.transport.runProtocolAction(requestOptions);
}
toString() {
return `${this.constructor.name} [name=${opts.commandName}]`;
}
complete(...args) {
if (isFunction(super.complete)) {
return super.complete(...args);
}
this.emit('complete', ...args);
}
}
const instance = new CommandInstance();
Object.keys(CommandLoader.interfaceMethods).forEach(method => {
const type = CommandLoader.interfaceMethods[method];
if (!BaseCommandLoader.isTypeImplemented(instance, method, type)) {
throw new Error(`Command class must implement method .${method}()`);
}
});
instance.stackTrace = opts.stackTrace;
instance.needsPromise = CommandLoader.isDeprecatedCommandStyle(CommandModule);
return instance;
}
get loadSubDirectories() {
return true;
}
createWrapper() {
if (this.module) {
// this place is only reached by client-commands, protocol commands and custom-commands (no assertions or element-commands).
if (this.isUserDefined) {
// only custom-commands will reach here.
// later extend this to client-commands and protocol commands as well.
Object.defineProperty(this.module, 'rejectNodeOnAbortFailure', {
configurable: true,
get() {
return true;
}
});
}
this.commandFn = function commandFn({args, stackTrace}) {
const instance = CommandLoader.createInstance(this.nightwatchInstance, this.module, {
stackTrace,
args,
commandName: this.commandName,
isUserDefined: this.isUserDefined
});
if (this.module.autoInvoke) {
this.nightwatchInstance.isES6AsyncCommand = instance.isES6AsyncCommand && this.isUserDefined;
return instance.command(...args);
}
if (instance.w3c_deprecated) {
const extraMessage = instance.deprecationNotice ? `\n ${instance.deprecationNotice}` : '';
// eslint-disable-next-line no-console
console.warn(`This command has been deprecated and is removed from the W3C Webdriver standard. It is only working with legacy Selenium JSONWire protocol.${extraMessage}`);
}
const result = this.resolveElementSelector(args)
.then(elementResult => {
if (elementResult) {
args[0] = elementResult;
}
this.nightwatchInstance.isES6AsyncCommand = instance.isES6AsyncCommand && this.isUserDefined;
return instance.command(...args);
})
.catch(err => {
if (instance instanceof EventEmitter) {
if (instance.needsPromise) {
// if the instance has `needsPromise` set to `true`, the `error` event is listened
// on the `context` object, not on the `instance` object (in `treenode.js`).
this.emit('error', err);
} else {
// for class-based commands that inherit from EventEmitter.
// Since the `needsPromise` is set to `false` in this case, the `complete` and `error`
// events are listened on the `instance` object.
instance.emit('error', err);
}
return;
}
if (!['NightwatchAssertError', 'NightwatchMountError', 'TestingLibraryError'].includes(err.name)) {
Logger.error(err);
instance.client.reporter.registerTestError(err);
}
return err;
})
.then(result => {
let reportErrors = instance.client.settings.report_command_errors;
const reportNetworkErrors = instance.client.settings.report_network_errors;
if (result && result.error && result.error.code && result.status === -1 && reportNetworkErrors) {
// node.js errors, e.g. ECONNRESET
reportErrors = true;
}
if (result && result.status === -1 && instance.reportProtocolErrors(result) && reportErrors) {
const err = new Error(`Error while running .${this.commandName}(): ${result.error}`);
if (result.stack) {
err.stack = result.stack;
}
if (result.error instanceof Error) {
result.error.registered = true;
} else {
err.registered = true;
}
Logger.error(err);
instance.client.reporter.registerTestError(err);
}
return result;
});
if (instance instanceof EventEmitter) {
return instance;
}
if (result instanceof Promise) {
return result;
}
return result;
};
}
return this;
}
getTargetNamespace(parent, namespacedApi) {
let namespace;
if (parent) {
namespace = super.getTargetNamespace(parent);
} else if (Array.isArray(this.namespace) && this.namespace.length > 0) {
namespace = BaseCommandLoader.unflattenNamespace(namespacedApi || this.api, this.namespace.slice());
}
return namespace;
}
}
module.exports = CommandLoader;
================================================
FILE: lib/api/_loaders/element-api.js
================================================
const {Locator} = require('../../element');
const Utils = require('../../utils');
const ScopedWebElement = require('../web-element');
const {By} = require('selenium-webdriver');
class ScopedElementAPILoader {
static get availableElementCommands() {
// commands directly available on `browser.element`
return [
['findElement', 'find', 'get'],
['findAll', 'findElements', 'getAll'],
['findByText'],
['findAllByText'],
['findByRole'],
['findAllByRole'],
['findByAltText'],
['findAllByAltText'],
['findByLabelText'],
['findByPlaceholderText'],
['findAllByPlaceholderText']
];
}
static isScopedElementCommand(commandName) {
return ScopedElementAPILoader.availableElementCommands.some(
commands => commands.includes(commandName)
);
}
constructor(nightwatchInstance) {
this.nightwatchInstance = nightwatchInstance;
}
createLocatingCommand(name) {
return Utils.setFunctionName((...args) => {
const rootElement = ScopedWebElement.root(this.nightwatchInstance, args);
return rootElement.createRootElementCommand(name, rootElement, args);
}, name);
}
loadElementMethods(target, element) {
const findActive = () => ScopedWebElement.active(this.nightwatchInstance);
const exportedElement = Object.assign(target, {
findActive,
getActive: findActive
});
ScopedElementAPILoader.availableElementCommands.forEach(commandName => {
let names = commandName;
if (!Array.isArray(names)) {
names = [names];
}
names.forEach(commandName => {
Object.defineProperty(exportedElement, commandName, {
value: this.createLocatingCommand.call(this, commandName, element),
writable: false
});
});
});
return exportedElement;
}
createElementMethod() {
const nightwatchInstance = this.nightwatchInstance;
return this.loadElementMethods(function(...args) {
let selector = args[0];
if (args.length >= 2 && Utils.isString(args[0]) && Utils.isString(args[1])) {
selector = By[Locator.AVAILABLE_LOCATORS[args[0]]](args[1]);
}
return ScopedWebElement.create(selector, null, nightwatchInstance);
});
}
}
module.exports = ScopedElementAPILoader;
================================================
FILE: lib/api/_loaders/element-command.js
================================================
const CommandLoader = require('./command.js');
const ElementCommand = require('../../element').Command;
class ElementCommandLoader extends CommandLoader {
static createInstance(CommandModule, opts) {
let ClassName = CommandModule || ElementCommand;
return new ClassName(opts);
}
createWrapper() {
if (this.module) {
this.commandFn = function commandFn({args, stackTrace}) {
const instance = ElementCommandLoader.createInstance(this.module, {
args,
commandName: this.commandName,
nightwatchInstance: this.nightwatchInstance
});
instance.stackTrace = stackTrace;
return instance.command();
};
}
return this;
}
}
module.exports = ElementCommandLoader;
================================================
FILE: lib/api/_loaders/element-global.js
================================================
const {until, WebElement} = require('selenium-webdriver');
const Utils = require('../../utils');
const {Logger, isUndefined, isObject, isString, isFunction} = Utils;
const isDefined = function(val) {
return !isUndefined(val);
};
const Element = require('../../element');
const {Locator} = Element;
class ElementGlobal {
static get availableElementCommands() {
return [
'getId',
['findElement', 'element', 'find', 'get'],
['findElements', 'findAll'],
'click',
'sendKeys',
['getTagName', 'tagName'],
['getCssValue', 'css'],
['getAttribute', 'attr', 'attribute'],
['getProperty', 'property', 'prop'],
['getText', 'text'],
['getAriaRole', 'ariaRole'],
['getAccessibleName', 'accessibleName'],
['getRect', 'rect'],
'isEnabled',
'isSelected',
'submit',
'clear',
'isDisplayed',
['takeScreenshot', 'screenshot']
];
}
static element({locator, testSuite, client, options}) {
const instance = new ElementGlobal({testSuite, client, options});
instance.setLocator(locator);
return instance.exported();
}
get api() {
return this.nightwatchInstance.api;
}
get reporter() {
return this.nightwatchInstance.reporter;
}
get commandQueue() {
return this.nightwatchInstance.queue;
}
get transport() {
return this.nightwatchInstance.transport;
}
get settings() {
return this.client ? this.client.settings : this.testSuite.settings;
}
constructor({testSuite, client, options = {}}) {
this.testSuite = testSuite;
this.client = client;
this.isComponent = options.isComponent || false;
this.componentType = this.isComponent && options.type;
this.suppressNotFoundErrors = false;
this.abortOnFailure = this.settings.globals.abortOnElementLocateError;
this.timeout = this.settings.globals.waitForConditionTimeout;
this.retryInterval = this.settings.globals.waitForConditionPollInterval;
this.init();
}
init() {
this.nightwatchInstance = this.testSuite && this.testSuite.client ? this.testSuite.client : this.client;
}
async findElement() {
if (this.element) {
return;
}
const {locator} = this;
if ((locator instanceof Element) && locator.resolvedElement) {
this.element = this.createWebElement(locator.resolvedElement);
return;
}
this.element = await this.transport.driver.wait(until.elementLocated(locator), this.timeout, null, this.retryInterval);
}
static isElementObject(element) {
if (!isObject(element)) {
return false;
}
if (!isString(element.selector)) {
return false;
}
const {
abortOnFailure, retryInterval, timeout, suppressNotFoundErrors, index
} = element;
return isDefined(abortOnFailure) || isDefined(retryInterval) || isDefined(timeout) || isDefined(suppressNotFoundErrors) || isDefined(index);
}
setPropertiesFromElement(element) {
const {
abortOnFailure, retryInterval, timeout, suppressNotFoundErrors, index
} = element;
if (isDefined(index)) {
this.index = index;
}
if (isDefined(abortOnFailure)) {
this.abortOnFailure = abortOnFailure;
}
if (isDefined(suppressNotFoundErrors)) {
this.suppressNotFoundErrors = suppressNotFoundErrors;
}
if (isDefined(retryInterval)) {
this.retryInterval = retryInterval;
}
if (isDefined(timeout)) {
this.timeout = timeout;
}
}
createWebElement(id) {
return new WebElement(this.transport.driver, id);
}
setLocator(locator) {
if (WebElement.isId(locator)) {
this.element = this.createWebElement(WebElement.extractId(locator));
return;
}
if (locator instanceof WebElement) {
this.element = locator;
return;
}
if (ElementGlobal.isElementObject(locator)) {
locator = Element.createFromSelector(locator);
}
if (locator instanceof Element) {
this.locator = locator;
} else {
let value;
if (isString(locator) && this.client && this.client.locateStrategy) {
value = {
value: locator,
using: this.client.locateStrategy
};
} else {
value = locator;
}
this.locator = Locator.create(value);
}
}
exported() {
const exportedElement = Element.createFromSelector(this.locator || this.element);
this.loadCommandsOntoObject(exportedElement);
return exportedElement;
}
computeArguments(args, commandName) {
if (args.length === 0) {
return args;
}
if (['findElements', 'findElement'].includes(commandName)) {
if (isString(args[0])) {
args[0] = {
value: args[0],
using: 'css selector'
};
} else if (isObject(args[0]) && args[0].selector) {
if (args[0] instanceof Element || ElementGlobal.isElementObject(args[0])) {
this.setPropertiesFromElement(args[0]);
}
args[0] = Locator.create(args[0]);
}
}
return args;
}
getComponentProperty(propName) {
return this.client.transportActions.executeScript(function(property) {
// eslint-disable-next-line
if (!window['@@component_element']) {
throw new Error('Component was not rendered.');
}
// eslint-disable-next-line
if (window['@@component_element'].componentVM) {
// eslint-disable-next-line
return window['@@component_element'].componentVM[property];
}
// eslint-disable-next-line
return window['@@component_element'][property];
}, [propName]).then(result => {
if (result.error instanceof Error) {
throw result.error;
}
return result.value;
});
}
createCommand(commandName, commandToExecute, nightwatchName) {
return function executeFn(...args) {
const deferred = Utils.createPromise();
const stackTrace = Utils.getOriginalStackTrace(executeFn);
this.init();
const {api, commandQueue, nightwatchInstance} = this;
const commandFn = async () => {
const isElement = await this.setElement(stackTrace);
if (!isElement) {
return null;
}
if (commandName === 'findElement' && args.length === 0) {
return this.element;
}
args = this.computeArguments(args, commandName);
let value;
let error;
try {
if (['getProperty', 'property', 'prop'].includes(nightwatchName) && this.isComponent && this.componentType) {
value = await this.getComponentProperty(args[0]);
} else {
value = await this.element[commandName].apply(this.element, args);
}
} catch (err) {
error = err;
}
if (['find', 'get', 'element'].includes(nightwatchName) && (value instanceof WebElement)) {
value = ElementGlobal.element({locator: value, client: nightwatchInstance});
} else if (nightwatchName === 'findAll') {
value = value.map(element => {
if (element instanceof WebElement) {
return ElementGlobal.element({locator: element, client: nightwatchInstance});
}
return element;
});
}
const lastArg = args[args.length - 1];
if (isFunction(lastArg)) {
if (error) {
return lastArg.call(this.api, {
value,
error,
status: 0
});
}
const callbackResult = lastArg.call(this.api, {
value,
status: 0
});
if (isDefined(callbackResult)) {
return callbackResult;
}
}
if (['find', 'get', 'element'].includes(nightwatchName) && error) {
return null;
}
if (error) {
throw error;
}
return value;
};
const isES6Async = true;
const node = commandQueue.add({
commandName: `element().${nightwatchName}`,
commandFn: commandToExecute ? commandToExecute({stackTrace}) : commandFn,
context: api,
args,
stackTrace,
namespace: null,
alwaysResolvePromise: true,
rejectPromise: true,
deferred,
isES6Async
});
Object.assign(node.deferred.promise, api);
if (commandName === 'findElement') {
node.deferred.promise['@nightwatch_element'] = true;
node.deferred.promise['@nightwatch_args'] = args;
if (this.isComponent) {
node.deferred.promise['@nightwatch_component'] = true;
}
} else if (commandName === 'findElements') {
node.deferred.promise['@nightwatch_multiple_elements'] = true;
}
return node.deferred.promise;
}.bind(this);
}
async setElement(stackTrace) {
try {
await this.findElement();
return true;
} catch (err) {
if (this.suppressNotFoundErrors) {
return null;
}
err.stack = stackTrace;
Logger.error(err);
if (this.abortOnFailure) {
this.reporter.registerTestError(err);
}
return null;
}
}
loadCommandsOntoObject(exportedElement) {
ElementGlobal.availableElementCommands.forEach(commandName => {
let names = commandName;
if (!Array.isArray(names)) {
names = [names];
}
const seleniumName = names[0];
names.forEach(commandName => {
Object.defineProperty(exportedElement, commandName, {
value: this.createCommand.call(this, seleniumName, null, commandName),
writable: false
});
});
});
Object.defineProperty(exportedElement, 'getWebElement', {
value: this.createCommand.call(this, 'getWebElement', ({stackTrace}) => {
return async () => {
const isElement = await this.setElement(stackTrace);
if (!isElement) {
return null;
}
return this.element;
};
}),
writable: false
});
if (this.isComponent) {
Object.defineProperty(exportedElement, 'isComponent', {
value: this.isComponent,
writable: false
});
}
return this;
}
}
module.exports = ElementGlobal;
================================================
FILE: lib/api/_loaders/ensure.js
================================================
const util = require('util');
const {until, WebElement} = require('selenium-webdriver');
const EventEmitter = require('events');
const Utils = require('../../utils');
const {AssertionRunner} = require('../../assertion');
const Element = require('../../element');
const BaseLoader = require('./_base-loader.js');
const {Locator} = Element;
const {Logger} = Utils;
class SeleniumCommand extends EventEmitter {
constructor({negate, args, settings, commandName}) {
super();
this.negate = negate;
this.commandName = commandName;
this.settings = settings;
this.defaultTimeout = this.settings.globals.waitForConditionTimeout;
this.retryInterval = this.settings.globals.waitForConditionPollInterval;
this.args = args;
this.actual = null;
this.message = '';
this.setExpected();
}
setExpected() {
let operator = this.getVerb();
this.expected = `${operator} '${this.args[0]}'`;
}
isElementCommand() {
return EnsureAssertionLoader.elementCommands.includes(this.commandName);
}
requiresLocatingElement() {
return EnsureAssertionLoader.requiresLocating.includes(this.commandName);
}
getVerb() {
let message = EnsureAssertionLoader.assertOperators[this.commandName];
let actionVerb;
let operator;
if (Utils.isString(message)) {
actionVerb = EnsureAssertionLoader.defaultVerb;
} else if (Array.isArray(message) && message[1]) {
actionVerb = message[1];
}
operator = this.negate ? actionVerb[1] : actionVerb[0];
return operator;
}
getMessage(passed) {
let message = EnsureAssertionLoader.assertOperators[this.commandName];
if (!message) {
return '';
}
let operator = this.getVerb();
if (Array.isArray(message)) {
message = message[0];
}
message = this.isElementCommand() ?
util.format(message, this.args[0], operator) :
util.format(message, operator, this.args[0]);
return message;
}
static isSeleniumElement(element) {
return (element instanceof WebElement);
}
async adaptElementArgument(transport) {
if (!this.requiresLocatingElement()) {
this.args[0] = Locator.create(this.args[0]);
return;
}
if (SeleniumCommand.isSeleniumElement(this.args[0])) {
return;
}
const locator = Locator.create(this.args[0]);
this.args[0] = await transport.driver.wait(until.elementLocated(locator), this.defaultTimeout);
}
async execute(transport) {
if (this.isElementCommand()) {
await this.adaptElementArgument(transport);
}
return transport.driver.wait(until[this.commandName](...this.args), this.defaultTimeout, undefined, this.retryInterval);
}
}
class EnsureAssertionLoader extends BaseLoader {
static get defaultVerb() {
return ['is', 'is not'];
}
static get assertOperators() {
return {
ableToSwitchToFrame: 'browser driver %s able to switch to the designated frame',
alertIsPresent: 'alert %s present',
titleIs: 'title %s %s',
titleContains: ['title %s %s', ['contains', 'does not contain']],
titleMatches: ['title %s %s', ['matches', 'does not match']],
urlIs: 'url %s %s',
urlContains: ['url %s %s', ['contains', 'does not contain']],
urlMatches: ['url %s %s', ['matches', 'does not match']],
elementLocated: ['element "%s" %s located', ['is', 'is not']],
elementsLocated: ['elements "%s" %s located', ['are', 'are not']],
stalenessOf: 'element "%s" %s stale',
elementIsVisible: 'element "%s" %s visible',
elementIsNotVisible: 'element "%s" %s not visible',
elementIsEnabled: 'element "%s" %s enabled',
elementIsDisabled: 'element "%s" %s disabled',
elementIsSelected: 'element "%s" %s selected',
elementIsNotSelected: 'element "%s" %s not selected',
elementTextIs: 'element "%s" text %s',
elementTextContains: ['element "%s" text %s', ['contains', 'does not contain']],
elementTextMatches: ['element "%s" text %s', ['matches', 'does not match']]
};
}
static get elementCommands() {
return [
'elementLocated',
'elementsLocated',
'stalenessOf',
'elementIsVisible',
'elementIsNotVisible',
'elementIsEnabled',
'elementIsDisabled',
'elementIsSelected',
'elementIsNotSelected',
'elementTextIs',
'elementTextContains',
'elementTextMatches'
];
}
static get requiresLocating() {
return [
'stalenessOf',
'elementIsVisible',
'elementIsNotVisible',
'elementIsEnabled',
'elementIsDisabled',
'elementIsSelected',
'elementIsNotSelected',
'elementTextIs',
'elementTextContains',
'elementTextMatches'
];
}
async runAssertion({negate, args, commandName, abortOnFailure, assertFn}) {
const {reporter, transport, nightwatchInstance} = this;
const {settings} = nightwatchInstance;
const startTime = new Date();
const command = new SeleniumCommand({negate, args, settings, commandName});
const {stackTrace, expected} = command;
const message = command.getMessage();
let passed = !negate;
let actual = '';
try {
await command.execute(transport);
} catch (err) {
passed = !!negate;
const lines = err.message.split('\n');
if (!negate) {
Logger.error(err);
}
if (lines.length > 1) {
actual = lines[1];
} else {
actual = err.message;
}
command.error = err;
}
const elapsedTime = new Date() - startTime;
const runner = new AssertionRunner({
passed,
err: {
expected, actual
}, message, calleeFn: assertFn, abortOnFailure, stackTrace, reporter, elapsedTime
});
return runner.run();
}
/**
* @param commandName
* @param abortOnFailure
* @returns {Function}
*/
createAssertion(commandName, abortOnFailure) {
return function assertFn({negate, args}) {
const namespace = 'ensure';
const isES6Async = Utils.isUndefined(this.isES6Async) ? (this.nightwatchInstance.isES6AsyncTestcase || this.nightwatchInstance.settings.always_async_commands) : this.isES6Async;
const commandFn = () => {
return this.runAssertion({
negate,
args,
commandName,
abortOnFailure,
assertFn
});
};
const deferred = Utils.createPromise();
const node = this.commandQueue.add({
commandName: negate ? `not.${commandName}` : commandName,
commandFn,
context: this.api,
args: [],
stackTrace: assertFn.stackTrace,
namespace,
deferred,
isES6Async
});
if (isES6Async) {
this.commandQueue.tree.once('asynctree:finished', (err) => {
node.deferred.resolve();
});
Object.assign(node.deferred.promise, this.api);
return node.deferred.promise;
}
return this.api;
}.bind(this);
}
/**
*
* @param {object} [parent]
* @return {ApiLoader}
*/
loadAssertions(parent = null) {
Object.keys(until).forEach(propertyName => {
let namespace;
if (parent) {
namespace = parent.ensure = parent.ensure || {};
}
this.nightwatchInstance.setApiMethod(propertyName, namespace || 'ensure', (function(commandName) {
return this.createAssertion(commandName, false);
}.bind(this))(propertyName));
});
return this;
}
}
module.exports = EnsureAssertionLoader;
================================================
FILE: lib/api/_loaders/expect-assertion.js
================================================
const chaiNightwatch = require('chai-nightwatch');
const BaseLoader = require('./_base-loader.js');
class ExpectAssertionLoader extends BaseLoader {
static get ChaiAssertionType() {
return {
PROPERTY: 'property',
METHOD: 'method'
};
}
static getChaiAssertionType(assertionType) {
const {PROPERTY, METHOD} = ExpectAssertionLoader.ChaiAssertionType;
switch (assertionType) {
case PROPERTY:
return 'addProperty';
case METHOD:
return 'addMethod';
}
}
static createMatcher({
assertionType,
commandName,
aliases = [],
nightwatchInstance,
AssertModule,
expectCommandName
}) {
if (!Array.isArray(commandName)) {
commandName = [commandName];
}
const method = ExpectAssertionLoader.getChaiAssertionType(assertionType);
commandName.forEach(command => {
const assertFn = function(...args) {
const assertion = new AssertModule({nightwatchInstance, chaiExpect: this, expectCommandName});
assertion.init(...args);
this.assertion = assertion;
return this;
};
if (!Array.isArray(aliases)) {
throw new Error(`Error while creating expect assertion: .aliases property needs to be an Array; received: ${aliases}`);
}
aliases.push(command);
aliases.forEach(alias => chaiNightwatch.Assertion[method](alias, assertFn));
});
}
loadAssertion(expectCommandName) {
if (!this.commandName) {
return;
}
const {nightwatchInstance} = this;
const assertionType = this.module.assertionType;
const commandName = this.module.assertionName || this.commandName;
const aliases = this.module.aliases;
ExpectAssertionLoader.createMatcher({
nightwatchInstance,
assertionType,
commandName,
expectCommandName,
aliases,
AssertModule: this.module
});
}
}
module.exports = ExpectAssertionLoader;
================================================
FILE: lib/api/_loaders/expect.js
================================================
const chai = require('chai-nightwatch');
const path = require('path');
const fs = require('fs');
const Utils = require('../../utils');
const BaseCommandLoader = require('./_command-loader.js');
const ExpectAssertionLoader = require('./expect-assertion.js');
class ExpectLoader extends BaseCommandLoader {
static get interfaceMethods() {
return {
command: 'function'
};
}
static createInstance(nightwatchInstance, CommandModule, opts) {
const commandInstance = new CommandModule({
nightwatchInstance,
commandName: opts.commandName,
commandArgs: opts.args
});
Object.keys(ExpectLoader.interfaceMethods).forEach(method => {
const type = ExpectLoader.interfaceMethods[method];
if (!BaseCommandLoader.isTypeImplemented(commandInstance, method, type)) {
throw new Error(`Command class must implement method .${method}()`);
}
});
return commandInstance;
}
createWrapper(abortOnFailure) {
if (this.module) {
this.abortOnFailure = abortOnFailure;
const commandName = this.commandName;
this.commandFn = function commandFn({args, stackTrace}) {
this.stackTrace = stackTrace;
const flagsOk = this.checkFlags();
if (!flagsOk) {
this.emit('error', new Error(`Incomplete expect assertion for "expect.${commandName}()". Please consult the docs at https://nightwatchjs.org/api/expect/`));
return this;
}
if ((args[0] instanceof Promise) && args[0]['@nightwatch_element']) {
let selector = '';
const elementArgs = args[0]['@nightwatch_args'] || [];
if (elementArgs[0] && elementArgs[0].value) {
selector = elementArgs[0].value;
}
args[0].then(result => {
args[0] = result;
if (!result) {
const err = new Error(`Unable to find element <${selector}>.`);
err.isExpect = true;
this.emit('error', err);
return this;
}
this.run(...args);
});
} else {
this.run(...args);
}
this.promise.catch(err => {
if (!(this.instance instanceof chai.Assertion)) {
this.emit('error', new Error(this.promiseRejectedMsg || `An error occurred while running .expect.${commandName}`));
}
});
return this;
};
}
return this;
}
define(parent = null) {
const {commandName, nightwatchInstance, commandFn, commandQueue} = this;
const namespace = (parent || nightwatchInstance.api).expect;
nightwatchInstance.setApiMethod(commandName, namespace, function queuedCommandFn(...args) {
const stackTrace = Utils.getOriginalStackTrace(queuedCommandFn);
const expectCommand = ExpectLoader.createInstance(nightwatchInstance, this.module, {
args,
commandName
});
const isAsyncCommand = this.isES6Async;
const isES6Async = Utils.isUndefined(this.isES6Async) ? (nightwatchInstance.isES6AsyncTestcase || nightwatchInstance.settings.always_async_commands) : isAsyncCommand;
const {deferred} = expectCommand;
this.loadAssertions(expectCommand);
const node = commandQueue.add({
commandName,
namespace: 'expect',
commandFn,
deferred,
context: expectCommand,
isAsyncCommand,
isES6Async,
args,
stackTrace
});
if (isES6Async && (expectCommand.instance instanceof Promise)) {
// prevent unhandledRejection errors
expectCommand.instance.catch(err => {
deferred.reject(err);
});
}
return expectCommand.instance;
}.bind(this));
}
loadAssertions(expectCommand) {
const {nightwatchInstance, commandName} = this;
// expect commands like .element() and .elements() have individual assertions (e.g. visible, present... / count);
// however expect commands like .url(), .title(), and .cookie only have an implicit assertion which is based on their value
if (expectCommand.hasAssertions) {
const assertionsPath = path.join(__dirname, '../expect/assertions', expectCommand.assertionsPath || commandName);
let modules = fs.readdirSync(assertionsPath);
modules = modules.filter(moduleName => {
return !moduleName.startsWith('_');
});
modules.forEach(assertionFileName => {
const loader = new ExpectAssertionLoader(nightwatchInstance);
loader
.loadModule(assertionsPath, assertionFileName)
.loadAssertion(commandName);
});
}
}
}
module.exports = ExpectLoader;
================================================
FILE: lib/api/_loaders/firefox.js
================================================
const BaseLoader = require('./_base-loader.js');
class FirefoxCommandLoader extends BaseLoader {
static get firefoxCommands() {
return [
'getContext',
'setContext',
'installAddon',
'uninstallAddon'
];
}
loadCommands() {
const commands = FirefoxCommandLoader.firefoxCommands;
this.loadDriverCommands({
commands,
namespace: 'firefox'
});
return this;
}
}
module.exports = FirefoxCommandLoader;
================================================
FILE: lib/api/_loaders/page-object.js
================================================
const lodashMerge = require('lodash/merge');
const BaseLoader = require('./_base-loader.js');
const Page = require('../../page-object');
let __page_object_cache = null;
class PageObjectLoader extends BaseLoader {
get loadSubDirectories() {
return true;
}
get pageObjectCache() {
return __page_object_cache;
}
static loadApiCommands(nightwatchInstance) {
__page_object_cache = {
__is_page_object_cache: true
};
const ApiLoader = require('../index.js');
const StaticApis = require('./static.js');
const apiLoader = new ApiLoader(nightwatchInstance);
const staticApis = new StaticApis(nightwatchInstance);
staticApis.loadStaticAssertions(__page_object_cache);
staticApis.loadStaticExpect(__page_object_cache);
if (nightwatchInstance.startSessionEnabled) {
return apiLoader.loadCustomCommands(__page_object_cache)
.then(() => apiLoader.loadCustomAssertions(__page_object_cache))
.then(() => apiLoader.loadApiCommandsSync(__page_object_cache))
.then(() => apiLoader.loadPlugins(__page_object_cache))
.then(() => {
// TODO: possibly load .ensure assertions as well
__page_object_cache.expect.section = __page_object_cache.expect.element;
});
}
return Promise.resolve();
}
loadApi(pageObject) {
const result = lodashMerge(pageObject, this.pageObjectCache);
return result;
}
createWrapper() {
return this;
}
pageObjectDefinition() {
return new Page(this.module, this.loadApi.bind(this), this.nightwatchInstance);
}
define() {
if (this.module) {
const parent = this.api.page;
let namespace;
if (Array.isArray(this.namespace) && this.namespace.length > 0) {
namespace = BaseLoader.unflattenNamespace(parent, this.namespace.slice());
}
try {
this.module.name = this.commandName;
// eslint-disable-next-line
} catch (err) {}
this.nightwatchInstance.setApiMethod(this.commandName, namespace || 'page', this.pageObjectDefinition.bind(this));
}
}
}
module.exports = PageObjectLoader;
================================================
FILE: lib/api/_loaders/plugin.js
================================================
const fs = require('fs');
const path = require('path');
const Utils = require('../../utils');
const __plugins = {};
module.exports = class PluginLoader {
static get plugins() {
return __plugins;
}
static load(pluginName) {
try {
if (PluginLoader.plugins[pluginName]) {
return PluginLoader.plugins[pluginName];
}
const plugin = {};
const pluginPath = Utils.getPluginPath(pluginName);
const dirName = path.dirname(pluginPath);
plugin.instance = require(pluginPath);
let isFolder;
try {
isFolder = fs.lstatSync(path.join(dirName, 'nightwatch')).isDirectory();
} catch (e) {
plugin.hasFolder = false;
}
if (isFolder) {
// load custom commands, if any
const commandsFolder = path.join(dirName, 'nightwatch', 'commands');
try {
const hasCommands = fs.lstatSync(commandsFolder).isDirectory();
if (hasCommands) {
plugin.commands = commandsFolder;
}
} catch (err) {
plugin.commands = false;
}
// load custom assertions, if any
const assertionsFolder = path.join(dirName, 'nightwatch', 'assertions');
try {
const hasAssertions = fs.lstatSync(assertionsFolder).isDirectory();
if (hasAssertions) {
plugin.assertions = assertionsFolder;
}
} catch (err) {
plugin.assertions = false;
}
// load plugin globals, if defined
const globalsPath = path.join(dirName, 'nightwatch', 'globals.js');
plugin.globals = fs.existsSync(globalsPath) ? Utils.requireModule(globalsPath) : false;
// load plugin transforms, if defined
const transformsPath = path.join(dirName, 'nightwatch', 'transforms.js');
plugin.transforms = fs.existsSync(transformsPath) ? Utils.requireModule(transformsPath) : null;
}
PluginLoader.plugins[pluginName] = plugin;
return PluginLoader.plugins[pluginName];
} catch (err) {
const msg = err.message.split('\n')[0];
const error = new Error(`Unable to load plugin: ${pluginName}: [${err.code}] ${msg}`);
error.showTrace = true;
error.displayed = false;
throw error;
}
}
};
================================================
FILE: lib/api/_loaders/static.js
================================================
const util = require('util');
const chai = require('@nightwatch/chai');
const assertModule = require('assert');
const EventEmitter = require('events');
const Utils = require('../../utils');
const Element = require('../../element');
const chaiExpect = chai.expect;
const {flag} = chai.util;
const {AssertionRunner} = require('../../assertion');
const namespacedApi = require('../../core/namespaced-api.js');
let __last_deferred__ = null;
module.exports = class StaticAssert {
static get assertOperators() {
return {
ok: ['ok', 'ko'],
equal: ['==', '!='],
notEqual: ['!=', '=='],
deepEqual: ['deepEqual', 'not deepEqual'],
notDeepEqual: ['not deepEqual', 'deepEqual'],
strictEqual: ['===', '!=='],
notStrictEqual: ['!==', '==='],
deepStrictEqual: ['deep strict equal', 'not deep strict equal'],
throws: ['throws', 'doesNotThrow'],
doesNotThrow: ['doesNotThrow', 'throws'],
match: ['matches', 'does not match'],
fail: 'fail',
ifError: 'ifError'
};
}
static get lastDeferred() {
return __last_deferred__;
}
static set lastDeferred(value) {
__last_deferred__ = value;
}
get api() {
return this.nightwatchInstance.api;
}
get reporter() {
return this.nightwatchInstance.reporter;
}
get commandQueue() {
return this.nightwatchInstance.queue;
}
constructor(nightwatchInstance) {
this.nightwatchInstance = nightwatchInstance;
}
/**
* Extends the node.js assert module
*
* @param commandName
* @param abortOnFailure
* @param apiToReturn
* @returns {Function}
*/
createStaticAssertion(commandName, abortOnFailure, apiToReturn) {
class Assertion extends EventEmitter {
constructor({negate, args}) {
super();
StaticAssert.lastDeferred = null;
this.negate = negate;
this.args = args;
this.passed = null;
this.expected = null;
this.actual = null;
const lastArgument = args[args.length - 1];
const isLastArgString = Utils.isString(lastArgument);
this.message = isLastArgString && (args.length > 2 || Utils.isBoolean(args[0])) && lastArgument ||
Utils.isFunction(args[0]) && '[Function]';
}
getMessage(propName) {
if (!Array.isArray(StaticAssert.assertOperators[propName])) {
return StaticAssert.assertOperators[propName] || '';
}
const operator = (this.passed && !this.negate) ? StaticAssert.assertOperators[propName][0] : StaticAssert.assertOperators[propName][1];
let message = '';
if (this.negate) {
message += ' not ';
}
if (this.args.length === 2) {
this.args.splice(1, 0, operator);
} else {
this.args.push(operator);
}
this.args = this.args.map(function(argument) {
if (Utils.isObject(argument)) {
argument = util.inspect(argument);
}
return argument;
});
return message + this.args.join(' ');
}
assert(propName) {
try {
assertModule[propName].apply(null, this.args);
this.passed = !this.negate;
this.message = `${this.negate ? 'Failed' : 'Passed'} [${propName}]: ${this.message || this.getMessage(propName)}`;
} catch (ex) {
this.passed = !!this.negate;
if (!this.passed && (ex instanceof Error) && propName === 'fail') {
this.message = ex.message;
} else {
this.message = `${this.negate ? 'Passed' : 'Failed'} [${propName}]: (${ex.message || this.message || this.getMessage(propName)})`;
}
if (Utils.isDefined(ex.showTrace)) {
this.showTrace = ex.showTrace;
}
if (Utils.isDefined(ex.link)) {
this.link = ex.link;
}
if (Utils.isDefined(ex.help)) {
this.help = ex.help;
}
this.actual = ex.actual;
this.expected = ex.expected;
this.stackTrace = ex.stack;
}
}
}
return function assertFn({negate, args}) {
const assertion = new Assertion({negate, args});
const {reporter, nightwatchInstance} = this;
assertion.assert(commandName);
const startTime = new Date();
const namespace = abortOnFailure ? 'assert' : 'verify';
const commandFn = () => {
const {passed, expected, actual, message, stackTrace, showTrace, link, help} = assertion;
const elapsedTime = new Date() - startTime;
this.runner = new AssertionRunner({
passed,
err: {
expected, actual
}, message, calleeFn: assertFn, abortOnFailure, stackTrace, showTrace, reporter, elapsedTime, link, help
});
return this.runner.run();
};
const isES6Async = nightwatchInstance.isES6AsyncTestcase || nightwatchInstance.settings.always_async_commands;
const deferred = Utils.createPromise();
const node = this.commandQueue.add({
commandName,
commandFn,
context: this.api,
args: [],
stackTrace: assertFn.stackTrace,
namespace,
deferred,
isES6Async
});
if (isES6Async || node.isES6Async) {
StaticAssert.lastDeferred = deferred;
Object.assign(node.deferred.promise, apiToReturn || this.api);
//prevent unhandled rejection
node.deferred.promise.catch(err => {
return StaticAssert.lastDeferred.reject(err);
});
return node.deferred.promise;
}
return apiToReturn || this.api;
}.bind(this);
}
/**
*
* @param {object} [parent]
* @return {ApiLoader}
*/
loadStaticAssertions(parent = null) {
Object.keys(assertModule).forEach(prop => {
let namespace;
if (parent) {
namespace = parent.assert = parent.assert || {};
}
let apiToReturn;
if (parent && parent.__is_page_object_cache) {
apiToReturn = parent;
}
const namespacedApiToReturn = (namespace) => {
return new Proxy(namespacedApi[namespace], {
get(_, name) {
return namespacedApi[namespace][name];
}
});
};
this.nightwatchInstance.setApiMethod(prop, namespace || 'assert', (function(prop) {
return this.createStaticAssertion(prop, true, apiToReturn);
}.bind(this))(prop));
if (!parent) {
this.nightwatchInstance.setNamespacedApiMethod(prop, 'assert', (function(prop) {
return this.createStaticAssertion(prop, true, namespacedApiToReturn('assert'));
}.bind(this))(prop));
}
if (this.nightwatchInstance.startSessionEnabled) {
let namespace;
if (parent) {
namespace = parent.verify = parent.verify || {};
}
this.nightwatchInstance.setApiMethod(prop, namespace || 'verify', (function(prop) {
return this.createStaticAssertion(prop, false);
}.bind(this))(prop));
if (!parent) {
this.nightwatchInstance.setNamespacedApiMethod(prop, 'verify', (function(prop) {
return this.createStaticAssertion(prop, true, namespacedApiToReturn('verify'));
}.bind(this))(prop));
}
}
});
return this;
}
/**
* @param {object} [parent]
*/
loadStaticExpect(parent = null) {
try {
this.nightwatchInstance.setApiMethod('expect', parent, (...args) => {
let obj = args[0];
const isElement = Element.isElementObject(obj) || Utils.isObject(obj) && obj['@nightwatch_element'];
if (!(obj instanceof Promise) && !isElement) {
args[0] = obj = new Promise(resolve => resolve(obj));
}
const assertion = chaiExpect(...args);
if (!obj) {
return assertion;
}
if (isElement) {
if (obj.isComponent || obj['@nightwatch_component']) {
return this.api.expect.component(...args);
}
return this.api.expect.element(...args);
}
flag(assertion, 'actionFn', (opts) => {
return this.addToQueue(opts);
});
return assertion;
});
} catch (err) {
this.nightwatchInstance.setApiMethod('expect', parent, {});
}
return this;
}
addToQueue() {
return function assertFn(valueDisplay, assertionName, handlerFn) {
const abortOnFailure = true;
const startTime = new Date();
const namespace = function() {
return 'expect(<value>)';
};
const {nightwatchInstance, reporter} = this;
const commandFn = () => {
let passed = true;
let expected;
let actual;
let message = `Expected ${valueDisplay} ${assertionName.join(' ')}: `;
const stackTrace = '';
try {
handlerFn();
} catch (err) {
passed = false;
expected = err.expected;
actual = err.actual;
message = err.message;
}
const elapsedTime = new Date() - startTime;
this.runner = new AssertionRunner({
passed,
err: {
expected, actual
}, message, calleeFn: assertFn, abortOnFailure, stackTrace, reporter, elapsedTime
});
return this.runner.run();
};
const isES6Async = nightwatchInstance.isES6AsyncTestcase || nightwatchInstance.settings.always_async_commands;
const deferred = Utils.createPromise();
const node = this.commandQueue.add({
commandName: assertionName.join('.'),
commandFn,
context: this.api,
args: [],
stackTrace: assertFn.stackTrace,
namespace,
deferred,
isES6Async
});
if (isES6Async) {
Object.assign(node.deferred.promise, this.api);
return node.deferred.promise;
}
return this.api;
}.bind(this);
}
};
================================================
FILE: lib/api/_loaders/within-context.js
================================================
const BaseLoader = require('./_base-loader.js');
const CommandWrapper = require('../../page-object/command-wrapper.js');
const Element = require('../../element');
const __commands_cache = {
__commands_cache: true
};
class WithinLoader extends BaseLoader {
get loadSubDirectories() {
return false;
}
static loadCommandCache(nightwatchInstance) {
if (!__commands_cache.loaded) {
const ApiLoader = require('../index.js');
const apiLoader = new ApiLoader(nightwatchInstance);
return new Promise(resolve => {
__commands_cache.loaded = true;
if (nightwatchInstance.startSessionEnabled) {
return apiLoader
.loadCustomCommands(__commands_cache)
.then(() => apiLoader.initPluginTransforms())
.then(() => apiLoader.loadPlugins(__commands_cache))
.then(() => resolve());
}
resolve();
});
}
return Promise.resolve();
}
loadApi(context) {
const ApiLoader = require('../index.js');
Object.keys(__commands_cache).forEach((command) => {
context[command] = ((commandName) => {
return (...args) => {
return this.nightwatchInstance.api[commandName](...args);
};
})(command);
});
const elementCommands = ApiLoader.getElementsCommandsStrict();
if (elementCommands.length > 0) {
elementCommands.forEach(command => {
context[command] = ((commandName) => {
return (...args) => {
return this.nightwatchInstance.api[commandName](...args);
};
})(command);
});
}
return context;
}
createWrapper() {
return this;
}
withinDefinition(...args) {
if (args.length !== 1) {
throw new Error('within() expects exactly one argument.');
}
this.__instance = new WithinContext(this.loadApi.bind(this), this.nightwatchInstance, args[0]);
return this.instance;
}
define() {
this.nightwatchInstance.setApiMethod('within', this.withinDefinition.bind(this));
}
}
class WithinContext {
get api() {
return this.__api;
}
get client() {
return this.__client;
}
get args() {
return this.__args;
}
constructor(loadApi, nightwatchInstance, container) {
this.commandLoader = loadApi;
this.__client = nightwatchInstance;
this.__api = Object.assign({}, nightwatchInstance.api);
this.__element = Element.createFromSelector(container);
this.__needsRecursion = true;
this.__promise = CommandWrapper.addWrappedCommandsAsync(this, this.commandLoader);
}
}
module.exports = WithinLoader;
================================================
FILE: lib/api/assertions/_assertionInstance.js
================================================
const util = require('util');
const EventEmitter = require('events');
const Utils = require('../../utils');
const Element = require('../../element');
const {Logger} = Utils;
class AssertionInstance {
static isElementNotFoundResult(result) {
if (!result) {
return false;
}
if (result.status === -1) {
result.value = result.value || [];
return result.value.length === 0;
}
return false;
}
static init({nightwatchInstance, args, fileName, options}) {
if (Utils.isFunction(args[args.length - 1])) {
this.__doneCallback = args.pop();
} else {
this.__doneCallback = function(result) {
return Promise.resolve(result);
};
}
this.__nightwatchInstance = nightwatchInstance;
this.__args = args;
this.fileName = fileName;
this.__negate = options.negate || false;
this.__commandResult = null;
this.retryAssertionTimeout = Utils.isObject(args[0]) ? args[0].timeout : undefined;
this.rescheduleInterval = Utils.isObject(args[0]) ? args[0].retryInterval : undefined;
}
constructor({nightwatchInstance, args, fileName, options} = {}, skipInit = false) {
if (!skipInit) {
AssertionInstance.init.call(this, {nightwatchInstance, args, fileName, options});
EventEmitter.prototype.constructor.call(this);
}
}
initialize() {
let msgReplaceArgs = this.args;
if (Utils.isFunction(this.formatMessage)) {
const format = this.formatMessage();
this.message = format.message;
if (this.message.includes('%s')) {
msgReplaceArgs = format.args;
}
} else {
msgReplaceArgs = msgReplaceArgs.map(arg => {
if (Utils.isObject(arg) && arg.selector) {
return `'<${arg.selector}>'`;
}
return `'${arg}'`;
});
}
if (this.message && this.message.includes('%s')) {
this.message = Logger.formatMessage(this.message, ...msgReplaceArgs);
}
}
set options(val) {
this.__options = val;
}
get options() {
return this.__options || {};
}
get result() {
return this.__commandResult;
}
set args(value) {
throw new Error(`Attempting to override ".args" which is a reserved property in "${this.fileName}".`);
}
set elementSelector(value) {
throw new Error(`Attempting to override ".elementSelector" which is a reserved property in "${this.fileName}".`);
}
set api(value) {
throw new Error(`Attempting to override ".api" which is a reserved property in "${this.fileName}".`);
}
get args() {
return this.__args;
}
get negate() {
return this.__negate;
}
/**
* @deprecated
*/
get client() {
return this.__nightwatchInstance.client;
}
get api() {
return this.__nightwatchInstance.api;
}
get doneCallback() {
return this.__doneCallback;
}
set doneCallback(value) {
this.__doneCallback = value;
}
get elementSelector() {
if (this.args[0] instanceof Element) {
return `<${this.args[0].toString()}>`;
}
if (Utils.isObject(this.args[0]) && this.args[0].selector) {
return this.args[0].selector ? `<${this.args[0].selector}>` : '';
}
if (Utils.isObject(this.args[0]) && this.args[0].webElementLocator) {
return `<${this.args[0].webElementLocator}>`;
}
if (this.args[0].id_ && this.args[0].driver_) {
return '<WebElement>';
}
const content = this.args[0];
return this.options.elementSelector ? `<${content}>` : `'${content}'`;
}
runFailure() {
const isFailed = this.failure(this.result);
if (isFailed && this.message.includes('%s')) {
this.message = Logger.formatMessage(this.message, this.args);
}
return isFailed;
}
hasFailure() {
if (Utils.isFunction(this.failure)) {
return this.runFailure();
}
if (!this.result || this.result.status === -1) {
return true;
}
const {error} = this.result;
return (error instanceof Error) && error.name !== 'NoSuchElementError';
}
getValue() {
if (Utils.isObject(this.result) && Utils.isUndefined(this.result.value) || this.result.status === -1) {
return null;
}
if (Utils.isFunction(this.value)) {
const result = this.value(this.result);
if (result === undefined) {
return null;
}
return result;
}
return this.result.value;
}
isOk(value = '') {
let passed;
// Backwards compatibility check:
// if there is a "pass" function declared, treat it like "evaluate" because "pass"
// needs to take the negate into account now
if (Utils.isFunction(this.pass)) {
passed = this.pass(value);
} else {
passed = this.evaluate(value);
}
return this.negate ? !passed : passed;
}
getActual() {
if (this.hasFailure()) {
const elementNotFound = AssertionInstance.isElementNotFoundResult(this.result);
return this.options.elementSelector ? (elementNotFound ? 'element could not be located' : 'error while locating the element') : '';
}
if (Utils.isFunction(this.actual)) {
const passed = this.evaluate(this.result.value);
return this.actual(passed);
}
return this.getValue();
}
/**
* @param {Object} result
*/
setResult(result) {
this.__commandResult = result;
}
}
module.exports.create = function(opts = {}) {
const {assertionModule, nightwatchInstance = {}, fileName, args = [], options = {}} = opts;
if (assertionModule.prototype && assertionModule.prototype.constructor.toString().startsWith('class')) {
const err = new Error('ES6 class assertions are not supported yet.');
err.help = [
'Please use the module.exports = function() { ... } syntax instead',
'If you have an ESM project, you need to use the .cjs extension'
];
err.link = 'https://nightwatchjs.org/guide/extending-nightwatch/adding-custom-assertions.html';
throw err;
}
const AssertionModule = Utils.isObject(assertionModule) && Utils.isFunction(assertionModule.assertion) ?
assertionModule.assertion :
assertionModule;
util.inherits(AssertionModule, EventEmitter);
util.inherits(AssertionInstance, AssertionModule);
const instance = new AssertionInstance({nightwatchInstance, args, fileName, options});
// call the assertion function
AssertionModule.prototype.constructor.apply(instance, args);
instance.initialize();
return instance;
};
================================================
FILE: lib/api/assertions/attributeContains.js
================================================
/**
* Checks if the given attribute of an element contains the expected value.
*
* @example
* this.demoTest = function (browser) {
* browser.assert.attributeContains('#someElement', 'href', 'google.com');
* };
*
* @method assert.attributeContains
* @param {string|object} definition The selector (CSS/Xpath) used to locate the element. Can either be a string or an object which specifies [element properties](https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html#postdoc-element-properties).
* @param {string} attribute The attribute name
* @param {string} expected The expected contained value of the attribute to check.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
*/
const {setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, attribute, expected, msg) {
this.options = {
elementSelector: true
};
this.formatMessage = function() {
const message = msg || `Testing if attribute %s of element %s ${this.negate ? 'doesn\'t contain %s' : 'contains %s'}`;
return {
message,
args: [`'${attribute}'`, this.elementSelector, `'${expected}'`]
};
};
this.evaluate = function(value) {
value = value || '';
return value.includes(expected);
};
this.actual = function() {
const value = this.getValue();
if (typeof value != 'string') {
return `Element does not have a '${attribute}' attribute`;
}
return value;
};
this.expected = function() {
return this.negate ? `not contains '${expected}'` : `contains '${expected}'`;
};
this.command = function(callback) {
return this.api.getAttribute(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), attribute, callback);
};
};
================================================
FILE: lib/api/assertions/attributeEquals.js
================================================
/**
* Checks if the given attribute of an element has the expected value.
*
* @example
* this.demoTest = function (browser) {
* browser.assert.attributeEquals('body', 'data-attr', 'some value');
* };
*
* @method assert.attributeEquals
* @param {string|object} definition The selector (CSS/Xpath) used to locate the element. Can either be a string or an object which specifies [element properties](https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html#postdoc-element-properties).
* @param {string} attribute The attribute name
* @param {string} expected The expected value of the attribute to check.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
*/
const {setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, attribute, expected, msg) {
this.options = {
elementSelector: true
};
this.formatMessage = function() {
const message = msg || `Testing if attribute %s of element %s ${this.negate ? 'doesn\'t equal %s' : 'equals %s'}`;
return {
message,
args: [`'${attribute}'`, this.elementSelector, `'${expected}'`]
};
};
this.evaluate = function(value) {
return value === expected;
};
this.actual = function(passed) {
const value = this.getValue();
if (typeof value != 'string') {
return `Element does not have a '${attribute}' attribute`;
}
return value;
};
this.expected = function() {
return this.negate ? `not equals '${expected}'` : `equals '${expected}'`;
};
this.command = function(callback) {
this.api.getAttribute(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), attribute, callback);
};
};
================================================
FILE: lib/api/assertions/attributeMatches.js
================================================
/**
* Check if an element's attribute value matches a regular expression.
*
* @example
* this.demoTest = function (browser) {
* browser.assert.attributeMatches('body', 'data-attr', '(value)');
* };
*
* @method assert.attributeMatches
* @param {string|object} definition The selector (CSS/Xpath) used to locate the element. Can either be a string or an object which specifies [element properties](https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html#postdoc-element-properties).
* @param {string} attribute The attribute name
* @param {string|RegExp} regexExpression Regex expression to match attribute value.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
*/
const {setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, attribute, regexExpression, msg) {
this.options = {
elementSelector: true
};
this.expected = function() {
return this.negate ? `does not matches '${regexExpression}'` : `matches '${regexExpression}'`;
};
this.formatMessage = function() {
const message = msg || `Testing if attribute %s of element %s ${this.negate ? 'doesn\'t matches %s' : 'matches %s'}`;
return {
message,
args: [`'${attribute}'`, this.elementSelector, `'${regexExpression}'`]
};
};
this.evaluate = function(value) {
const regex = value instanceof RegExp ? value : new RegExp(regexExpression);
return regex.test(value);
};
this.value = function(result = {}) {
return result.value || '';
};
this.command = function(callback) {
this.api.getAttribute(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), attribute, callback);
};
};
================================================
FILE: lib/api/assertions/contains.js
================================================
const Utils = require('../../utils/index.js');
exports.assertion = function (actual, expected, message) {
this.options = {
elementSelector: false
};
this.expected = function () {
return this.negate
? `does not contain ${expected}`
: `contains ${expected}`;
};
this.formatMessage = function () {
return {
args: [],
message: ''
};
};
this.refineFormattedMessage = function (value) {
const finalMessage =
message ||
`Testing if a value %s ${
this.negate ? 'does not contain %s' : 'contains %s'
}`;
this.message = finalMessage.includes('%s')
? Utils.Logger.formatMessage(finalMessage, value, expected)
: finalMessage;
};
this.evaluate = function (value) {
return value.includes(expected);
};
this.command = async function (callback) {
return callback({value: await actual}, null);
};
};
================================================
FILE: lib/api/assertions/containsText.js
================================================
/**
* Checks if the given element contains the specified text.
*
* ```
* this.demoTest = function (browser) {
* browser.assert.containsText('#main', 'The Night Watch');
* };
* ```
*
* @method assert.containsText
* @param {string|object} definition The selector (CSS/Xpath) used to locate the element. Can either be a string or an object which specifies [element properties](https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html#postdoc-element-properties).
* @param {string} expectedText The text to look for.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
* @deprecated
*/
const {setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, expectedText, msg) {
this.options = {
elementSelector: true
};
// eslint-disable-next-line no-console
console.warn('DEPRECATED: the assertion .containsText() has been deprecated and will be ' +
'removed from future versions. Use assert.textContains().');
/*!
* Returns the message format which will be used to output the message in the console and also
* the arguments which will be used for replace the place holders, used in the order of appearance
*/
this.formatMessage = function() {
const message = msg || `Testing if element %s ${this.negate ? 'does not contain text %s' : 'contains text %s'}`;
return {
message,
args: [this.elementSelector, `'${expectedText}'`]
};
};
/*!
* Returns the expected value of the assertion which is displayed in the case of a failure
*
* @return {string}
*/
this.expected = function() {
return this.negate ? `does not contain text '${expectedText}'` : `contains text '${expectedText}'`;
};
/*!
* Given the value, the condition used to evaluate if the assertion is passed
* @param {*} value
* @return {Boolean}
*/
this.evaluate = function(value) {
if (typeof value != 'string') {
return false;
}
return value.includes(expectedText);
};
/*!
* When defined, this method is called by the assertion runner with the command result, to determine if the
* value can be retrieved successfully from the result object
*
* @param result
* @return {boolean|*}
*/
this.failure = function(result) {
return result === false || result && result.status === -1;
};
/*!
* Called with the result object of the command to retrieve the value which is to be evaluated
*
* @param {Object} result
* @return {*}
*/
this.value = function(result) {
if (result.status === -1) {
return null;
}
return result.value;
};
/*!
* When defined, this method is called by the assertion runner with the command result to determine the actual
* state of the assertion in the event of a failure
*
* @param {Boolean} passed
* @return {string}
*/
this.actual = function(passed) {
return passed ? `contains '${expectedText}'` : `does not contain '${expectedText}'`;
};
/*!
* The command which is to be executed by the assertion runner
* @param {function} callback
*/
this.command = function(callback) {
this.api.getText(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), callback);
};
};
================================================
FILE: lib/api/assertions/cssClassNotPresent.js
================================================
/**
* Checks if the given element does not have the specified CSS class.
*
* ```
* this.demoTest = function (browser) {
* browser.assert.cssClassNotPresent('#main', 'container');
* };
* ```
*
* @method assert.cssClassNotPresent
* @param {string|object} definition The selector (CSS / Xpath) used to locate the element.
* @param {string} className The CSS class to look for.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
* @deprecated
*/
const classListRegexp = /\s/;
const classNameRegexp = /\w/;
const {setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, className, msg) {
this.options = {
elementSelector: true
};
// eslint-disable-next-line no-console
console.warn('DEPRECATED: the assertion .cssClassNotPresent() has been deprecated and will be ' +
'removed from future versions. Use assert.not.hasClass().');
this.formatMessage = function() {
let message = msg || 'Testing if element %s doesn\'t have css class %s';
return {
message,
args: [this.elementSelector, `'${className}'`]
};
};
this.expected = function() {
return `has not ${className}`;
};
this.evaluate = function() {
return !this.classList.includes(className);
};
this.value = function(result) {
this.classList = result.value
.split(classListRegexp)
.filter(item => classNameRegexp.test(item));
return result.value;
};
this.command = function(callback) {
this.api.getAttribute(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), 'class', callback);
};
};
================================================
FILE: lib/api/assertions/cssClassPresent.js
================================================
/**
* Checks if the given element has the specified CSS class. Multiple css classes can be specified either as an array or a space-delimited string.
*
* In case the expected value is a space delimited string, the order is not taken into account - each value will individually be checked against.
*
* ```
* this.demoTest = function (browser) {
* browser.assert.cssClassPresent('#main', 'container');
* browser.assert.cssClassPresent('#main', ['visible', 'container']);
* browser.assert.cssClassPresent('#main', 'visible container');
* };
* ```
*
* @method assert.cssClassPresent
* @param {string|object} definition The selector (CSS/Xpath) used to locate the element. Can either be a string or an object which specifies [element properties](https://nightwatchjs.org/guide/writing-tests/finding-interacting-with-dom-elements.html#postdoc-element-properties).
* @param {string} className The CSS class to look for.
* @param {string} [msg] Optional log message to display in the output. If missing, one is displayed by default.
* @api assertions
* @deprecated
*/
const classListRegexp = /\s/;
const classNameRegexp = /\w/;
const {containsMultiple, setElementSelectorProps} = require('../../utils');
exports.assertion = function(definition, expected, msg) {
this.options = {
elementSelector: true
};
// eslint-disable-next-line no-console
console.warn('DEPRECATED: the assertion .cssClassPresent() has been deprecated and will be ' +
'removed from future versions. Use assert.hasClass().');
this.formatMessage = function() {
const message = msg || `Testing if element %s ${this.negate ? 'doesn\'t have css class %s' : 'has css class %s'}`;
return {
message,
args: [this.elementSelector, `'${Array.isArray(expected) ? expected.join(' ') : expected}'`]
};
};
this.expected = function() {
return this.negate ? `has not ${expected}` : `has ${expected}`;
};
this.evaluate = function() {
if (!this.classList) {
return false;
}
return containsMultiple(this.classList, expected, ' ');
};
this.value = function(result) {
if (!result || !result.value) {
return '';
}
this.classList = result.value
.split(classListRegexp)
.filter(item => classNameRegexp.test(item));
return result.value;
};
this.command = function(callback) {
this.api.getAttribute(setElementSelectorProps(definition, {
suppressNotFoundErrors: true
}), 'class', callback);
};
};
================================================
FILE: lib/api/assertions/cssProperty.js
================================================
/**
* Checks if the specified css property of a given element has the expected value.
*
* @example
* this.demoTest = function (browser) {
* browser.assert.cssProperty(
gitextract_4_y53lij/
├── .eslintignore
├── .eslintrc
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.yml
│ │ ├── config.yml
│ │ └── feature-request.yml
│ ├── PULL_REQUEST_TEMPLATE.md
│ ├── label-commenter-config.yml
│ ├── stale.yml
│ └── workflows/
│ ├── build-node.yaml
│ ├── component-tests.yaml
│ ├── coverage.yml
│ ├── label-commenter.yml
│ ├── missing-types-comment.yml
│ ├── missing-types.yml
│ ├── nightly.yml
│ ├── publish.yml
│ └── type-declaration-tests.yml
├── .gitignore
├── .husky/
│ └── pre-commit
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE.md
├── README.md
├── api/
│ ├── README.md
│ └── index.js
├── bin/
│ ├── .gitignore
│ ├── nightwatch
│ ├── runner.js
│ └── show_survey.js
├── codecov.yml
├── examples/
│ ├── .gitignore
│ ├── cucumber-js/
│ │ ├── README.md
│ │ └── features/
│ │ ├── nightwatch.feature
│ │ └── step_definitions/
│ │ └── nightwatch.js
│ ├── custom-assertions/
│ │ └── testCustomAssertion.js
│ ├── custom-commands/
│ │ ├── angular/
│ │ │ └── getElementsInList.js
│ │ └── strictClick.js
│ ├── globals.json
│ ├── globalsModule.js
│ ├── pages/
│ │ ├── google/
│ │ │ ├── consent.js
│ │ │ ├── search.js
│ │ │ └── searchResults.js
│ │ └── nightwatchFeatures.js
│ ├── test-app/
│ │ ├── globals.js
│ │ ├── index.html
│ │ └── page2.html
│ ├── tests/
│ │ ├── README.md
│ │ ├── angularTodoTest.js
│ │ ├── bstackdemo/
│ │ │ ├── auth.js
│ │ │ └── checkout.js
│ │ ├── chromeCDP_example.js
│ │ ├── duckDuckGo.js
│ │ ├── ecosia.js
│ │ ├── element/
│ │ │ ├── dragAndDrop.js
│ │ │ ├── elementScreenshot.js
│ │ │ ├── elementapi-tests.js
│ │ │ └── isCommands.js
│ │ ├── google.js
│ │ ├── googlePageObject.js
│ │ ├── sample-with-relative-locators.js
│ │ ├── selectElement.js
│ │ ├── shadowRootExample.js
│ │ └── vueTodoList.js
│ ├── tsconfig.json
│ └── unittests/
│ ├── demoTestAsync.js
│ ├── testUtils.js
│ └── testUtilsWithChai.js
├── index.js
├── lib/
│ ├── api/
│ │ ├── _loaders/
│ │ │ ├── _base-loader.js
│ │ │ ├── _command-loader.js
│ │ │ ├── assertion-scheduler.js
│ │ │ ├── assertion.js
│ │ │ ├── chrome.js
│ │ │ ├── command.js
│ │ │ ├── element-api.js
│ │ │ ├── element-command.js
│ │ │ ├── element-global.js
│ │ │ ├── ensure.js
│ │ │ ├── expect-assertion.js
│ │ │ ├── expect.js
│ │ │ ├── firefox.js
│ │ │ ├── page-object.js
│ │ │ ├── plugin.js
│ │ │ ├── static.js
│ │ │ └── within-context.js
│ │ ├── assertions/
│ │ │ ├── _assertionInstance.js
│ │ │ ├── attributeContains.js
│ │ │ ├── attributeEquals.js
│ │ │ ├── attributeMatches.js
│ │ │ ├── contains.js
│ │ │ ├── containsText.js
│ │ │ ├── cssClassNotPresent.js
│ │ │ ├── cssClassPresent.js
│ │ │ ├── cssProperty.js
│ │ │ ├── domPropertyContains.js
│ │ │ ├── domPropertyEquals.js
│ │ │ ├── domPropertyMatches.js
│ │ │ ├── elementNotPresent.js
│ │ │ ├── elementPresent.js
│ │ │ ├── elementsCount.js
│ │ │ ├── enabled.js
│ │ │ ├── hasAttribute.js
│ │ │ ├── hasClass.js
│ │ │ ├── hasDescendants.js
│ │ │ ├── hidden.js
│ │ │ ├── promisedValue.js
│ │ │ ├── selected.js
│ │ │ ├── textContains.js
│ │ │ ├── textEquals.js
│ │ │ ├── textMatches.js
│ │ │ ├── title.js
│ │ │ ├── titleContains.js
│ │ │ ├── titleEquals.js
│ │ │ ├── titleMatches.js
│ │ │ ├── urlContains.js
│ │ │ ├── urlEquals.js
│ │ │ ├── urlMatches.js
│ │ │ ├── value.js
│ │ │ ├── valueContains.js
│ │ │ ├── valueEquals.js
│ │ │ └── visible.js
│ │ ├── client-commands/
│ │ │ ├── _base-command.js
│ │ │ ├── _locateStrategy.js
│ │ │ ├── alerts/
│ │ │ │ ├── accept.js
│ │ │ │ ├── dismiss.js
│ │ │ │ ├── getText.js
│ │ │ │ └── setText.js
│ │ │ ├── axeInject.js
│ │ │ ├── axeRun.js
│ │ │ ├── cookies/
│ │ │ │ ├── delete.js
│ │ │ │ ├── deleteAll.js
│ │ │ │ ├── get.js
│ │ │ │ ├── getAll.js
│ │ │ │ └── set.js
│ │ │ ├── debug.js
│ │ │ ├── deleteCookie.js
│ │ │ ├── deleteCookies.js
│ │ │ ├── document/
│ │ │ │ ├── executeAsyncScript.js
│ │ │ │ ├── executeScript.js
│ │ │ │ ├── injectScript.js
│ │ │ │ └── source.js
│ │ │ ├── enablePerformanceMetrics.js
│ │ │ ├── end.js
│ │ │ ├── getCookie.js
│ │ │ ├── getCookies.js
│ │ │ ├── getLog.js
│ │ │ ├── getLogTypes.js
│ │ │ ├── getPerformanceMetrics.js
│ │ │ ├── getTitle.js
│ │ │ ├── getWindowPosition.js
│ │ │ ├── getWindowRect.js
│ │ │ ├── getWindowSize.js
│ │ │ ├── init.js
│ │ │ ├── injectScript.js
│ │ │ ├── isLogAvailable.js
│ │ │ ├── logs/
│ │ │ │ ├── captureBrowserConsoleLogs.js
│ │ │ │ ├── captureBrowserExceptions.js
│ │ │ │ ├── getSessionLog.js
│ │ │ │ ├── getSessionLogTypes.js
│ │ │ │ └── isSessionLogAvailable.js
│ │ │ ├── maximizeWindow.js
│ │ │ ├── network/
│ │ │ │ ├── captureRequests.js
│ │ │ │ ├── mockResponse.js
│ │ │ │ └── setConditions.js
│ │ │ ├── pageSource.js
│ │ │ ├── pause.js
│ │ │ ├── perform.js
│ │ │ ├── registerBasicAuth.js
│ │ │ ├── resizeWindow.js
│ │ │ ├── saveScreenshot.js
│ │ │ ├── saveSnapshot.js
│ │ │ ├── setCookie.js
│ │ │ ├── setDeviceDimensions.js
│ │ │ ├── setGeolocation.js
│ │ │ ├── setWindowPosition.js
│ │ │ ├── setWindowRect.js
│ │ │ ├── setWindowSize.js
│ │ │ ├── takeHeapSnapshot.js
│ │ │ ├── urlHash.js
│ │ │ ├── useCss.js
│ │ │ ├── useXpath.js
│ │ │ ├── window/
│ │ │ │ ├── close.js
│ │ │ │ ├── fullscreen.js
│ │ │ │ ├── getAllHandles.js
│ │ │ │ ├── getHandle.js
│ │ │ │ ├── getPosition.js
│ │ │ │ ├── getRect.js
│ │ │ │ ├── getSize.js
│ │ │ │ ├── maximize.js
│ │ │ │ ├── minimize.js
│ │ │ │ ├── open.js
│ │ │ │ ├── setPosition.js
│ │ │ │ ├── setRect.js
│ │ │ │ ├── setSize.js
│ │ │ │ └── switchTo.js
│ │ │ └── within.js
│ │ ├── element-commands/
│ │ │ ├── _baseElementCommand.js
│ │ │ ├── _waitFor.js
│ │ │ ├── _waitForDisplayed.js
│ │ │ ├── check.js
│ │ │ ├── clearValue.js
│ │ │ ├── click.js
│ │ │ ├── clickAndHold.js
│ │ │ ├── doubleClick.js
│ │ │ ├── dragAndDrop.js
│ │ │ ├── findElement.js
│ │ │ ├── findElements.js
│ │ │ ├── getAccessibleName.js
│ │ │ ├── getAriaRole.js
│ │ │ ├── getAttribute.js
│ │ │ ├── getCssProperty.js
│ │ │ ├── getElementProperty.js
│ │ │ ├── getElementRect.js
│ │ │ ├── getElementSize.js
│ │ │ ├── getFirstElementChild.js
│ │ │ ├── getLastElementChild.js
│ │ │ ├── getLocation.js
│ │ │ ├── getLocationInView.js
│ │ │ ├── getNextSibling.js
│ │ │ ├── getPreviousSibling.js
│ │ │ ├── getShadowRoot.js
│ │ │ ├── getTagName.js
│ │ │ ├── getText.js
│ │ │ ├── getValue.js
│ │ │ ├── hasDescendants.js
│ │ │ ├── isEnabled.js
│ │ │ ├── isPresent.js
│ │ │ ├── isSelected.js
│ │ │ ├── isVisible.js
│ │ │ ├── moveToElement.js
│ │ │ ├── rightClick.js
│ │ │ ├── sendKeys.js
│ │ │ ├── setAttribute.js
│ │ │ ├── setPassword.js
│ │ │ ├── setValue.js
│ │ │ ├── submitForm.js
│ │ │ ├── takeElementScreenshot.js
│ │ │ ├── uncheck.js
│ │ │ ├── updateValue.js
│ │ │ ├── uploadFile.js
│ │ │ ├── waitForElementNotPresent.js
│ │ │ ├── waitForElementNotVisible.js
│ │ │ ├── waitForElementPresent.js
│ │ │ └── waitForElementVisible.js
│ │ ├── expect/
│ │ │ ├── _baseExpect.js
│ │ │ ├── assertions/
│ │ │ │ ├── _baseAssertion.js
│ │ │ │ ├── element/
│ │ │ │ │ ├── _element-assertion.js
│ │ │ │ │ ├── active.js
│ │ │ │ │ ├── attribute.js
│ │ │ │ │ ├── css.js
│ │ │ │ │ ├── enabled.js
│ │ │ │ │ ├── present.js
│ │ │ │ │ ├── property.js
│ │ │ │ │ ├── selected.js
│ │ │ │ │ ├── text.js
│ │ │ │ │ ├── type.js
│ │ │ │ │ ├── value.js
│ │ │ │ │ └── visible.js
│ │ │ │ └── elements/
│ │ │ │ └── count.js
│ │ │ ├── component.js
│ │ │ ├── cookie.js
│ │ │ ├── element.js
│ │ │ ├── elements.js
│ │ │ ├── title.js
│ │ │ └── url.js
│ │ ├── index.js
│ │ ├── protocol/
│ │ │ ├── _base-action.js
│ │ │ ├── acceptAlert.js
│ │ │ ├── appium/
│ │ │ │ ├── getContext.js
│ │ │ │ ├── getContexts.js
│ │ │ │ ├── getCurrentActivity.js
│ │ │ │ ├── getCurrentPackage.js
│ │ │ │ ├── getGeolocation.js
│ │ │ │ ├── getOrientation.js
│ │ │ │ ├── hideKeyboard.js
│ │ │ │ ├── isKeyboardShown.js
│ │ │ │ ├── longPressKeyCode.js
│ │ │ │ ├── pressKeyCode.js
│ │ │ │ ├── resetApp.js
│ │ │ │ ├── setContext.js
│ │ │ │ ├── setGeolocation.js
│ │ │ │ ├── setOrientation.js
│ │ │ │ └── startActivity.js
│ │ │ ├── back.js
│ │ │ ├── closeWindow.js
│ │ │ ├── contexts.js
│ │ │ ├── cookie.js
│ │ │ ├── currentContext.js
│ │ │ ├── dismissAlert.js
│ │ │ ├── element.js
│ │ │ ├── elementActive.js
│ │ │ ├── elementIdAttribute.js
│ │ │ ├── elementIdClear.js
│ │ │ ├── elementIdClick.js
│ │ │ ├── elementIdCssProperty.js
│ │ │ ├── elementIdDisplayed.js
│ │ │ ├── elementIdDoubleClick.js
│ │ │ ├── elementIdElement.js
│ │ │ ├── elementIdElements.js
│ │ │ ├── elementIdEnabled.js
│ │ │ ├── elementIdEquals.js
│ │ │ ├── elementIdLocation.js
│ │ │ ├── elementIdLocationInView.js
│ │ │ ├── elementIdName.js
│ │ │ ├── elementIdProperty.js
│ │ │ ├── elementIdSelected.js
│ │ │ ├── elementIdSize.js
│ │ │ ├── elementIdText.js
│ │ │ ├── elementIdValue.js
│ │ │ ├── elements.js
│ │ │ ├── forward.js
│ │ │ ├── frame.js
│ │ │ ├── frameParent.js
│ │ │ ├── fullscreenWindow.js
│ │ │ ├── getAlertText.js
│ │ │ ├── getCurrentUrl.js
│ │ │ ├── getOrientation.js
│ │ │ ├── keys.js
│ │ │ ├── minimizeWindow.js
│ │ │ ├── mouseButtonClick.js
│ │ │ ├── mouseButtonDown.js
│ │ │ ├── mouseButtonUp.js
│ │ │ ├── moveTo.js
│ │ │ ├── navigateTo.js
│ │ │ ├── openNewWindow.js
│ │ │ ├── quit.js
│ │ │ ├── refresh.js
│ │ │ ├── releaseMouseButton.js
│ │ │ ├── screenshot.js
│ │ │ ├── session.js
│ │ │ ├── sessionLog.js
│ │ │ ├── sessionLogTypes.js
│ │ │ ├── sessions.js
│ │ │ ├── setAlertText.js
│ │ │ ├── setContext.js
│ │ │ ├── setOrientation.js
│ │ │ ├── source.js
│ │ │ ├── status.js
│ │ │ ├── submit.js
│ │ │ ├── switchToWindow.js
│ │ │ ├── timeouts.js
│ │ │ ├── timeoutsAsyncScript.js
│ │ │ ├── timeoutsImplicitWait.js
│ │ │ ├── title.js
│ │ │ ├── url.js
│ │ │ ├── waitUntil.js
│ │ │ ├── windowHandle.js
│ │ │ ├── windowHandles.js
│ │ │ ├── windowMaximize.js
│ │ │ ├── windowPosition.js
│ │ │ ├── windowRect.js
│ │ │ └── windowSize.js
│ │ └── web-element/
│ │ ├── assert/
│ │ │ ├── element-assertions.js
│ │ │ ├── elements-assertions.js
│ │ │ └── value-assertions.js
│ │ ├── commands/
│ │ │ ├── check.js
│ │ │ ├── clear.js
│ │ │ ├── click.js
│ │ │ ├── clickAndHold.js
│ │ │ ├── doubleClick.js
│ │ │ ├── dragAndDrop.js
│ │ │ ├── find.js
│ │ │ ├── findAll.js
│ │ │ ├── findAllByAltText.js
│ │ │ ├── findAllByPlaceholderText.js
│ │ │ ├── findAllByRole.js
│ │ │ ├── findAllByText.js
│ │ │ ├── findByAltText.js
│ │ │ ├── findByLabelText.js
│ │ │ ├── findByPlaceholderText.js
│ │ │ ├── findByRole.js
│ │ │ ├── findByText.js
│ │ │ ├── getAccessibleName.js
│ │ │ ├── getAriaRole.js
│ │ │ ├── getAttribute.js
│ │ │ ├── getCssProperty.js
│ │ │ ├── getFirstElementChild.js
│ │ │ ├── getId.js
│ │ │ ├── getLastElementChild.js
│ │ │ ├── getNextElementSibling.js
│ │ │ ├── getParentElement.js
│ │ │ ├── getPreviousElementSibling.js
│ │ │ ├── getProperty.js
│ │ │ ├── getRect.js
│ │ │ ├── getShadowRoot.js
│ │ │ ├── getTagName.js
│ │ │ ├── getText.js
│ │ │ ├── getValue.js
│ │ │ ├── inspectInDevTools.js
│ │ │ ├── isActive.js
│ │ │ ├── isEnabled.js
│ │ │ ├── isPresent.js
│ │ │ ├── isSelected.js
│ │ │ ├── isVisible.js
│ │ │ ├── moveTo.js
│ │ │ ├── rightClick.js
│ │ │ ├── sendKeys.js
│ │ │ ├── setAttribute.js
│ │ │ ├── setProperty.js
│ │ │ ├── setValue.js
│ │ │ ├── submit.js
│ │ │ ├── takeScreenshot.js
│ │ │ ├── uncheck.js
│ │ │ ├── update.js
│ │ │ └── upload.js
│ │ ├── element-locator.js
│ │ ├── element-value.js
│ │ ├── factory.js
│ │ ├── index.js
│ │ ├── scoped-element.js
│ │ ├── scoped-elements.js
│ │ └── waitUntil.js
│ ├── assertion/
│ │ ├── assertion-error.js
│ │ ├── assertion-runner.js
│ │ ├── assertion.js
│ │ └── index.js
│ ├── core/
│ │ ├── asynctree.js
│ │ ├── client.js
│ │ ├── namespaced-api.js
│ │ ├── queue.js
│ │ └── treenode.js
│ ├── element/
│ │ ├── appium-locator.js
│ │ ├── command.js
│ │ ├── index.js
│ │ ├── locate/
│ │ │ ├── elements-by-recursion.js
│ │ │ ├── recursive-lookup.js
│ │ │ └── single-element-by-recursion.js
│ │ ├── locator-factory.js
│ │ ├── locator.js
│ │ └── strategy.js
│ ├── http/
│ │ ├── auth.js
│ │ ├── formatter.js
│ │ ├── http.js
│ │ ├── options.js
│ │ ├── request.js
│ │ └── response.js
│ ├── index.js
│ ├── page-object/
│ │ ├── base-object.js
│ │ ├── command-wrapper.js
│ │ ├── index.js
│ │ └── section.js
│ ├── reporter/
│ │ ├── axe-report.js
│ │ ├── base-reporter.js
│ │ ├── global-reporter.js
│ │ ├── index.js
│ │ ├── reporters/
│ │ │ ├── html.js
│ │ │ ├── json.js
│ │ │ ├── junit.js
│ │ │ ├── junit.xml.ejs
│ │ │ └── minimalJson.js
│ │ ├── results.js
│ │ ├── simplified.js
│ │ └── summary.js
│ ├── runner/
│ │ ├── androidEmulator.js
│ │ ├── cli/
│ │ │ ├── argv-setup.js
│ │ │ ├── cli.js
│ │ │ └── nightwatch.conf.ejs
│ │ ├── concurrency/
│ │ │ ├── child-process.js
│ │ │ ├── index.js
│ │ │ ├── task.js
│ │ │ ├── worker-process.js
│ │ │ └── worker-task.js
│ │ ├── eventHub.js
│ │ ├── folder-walk.js
│ │ ├── matchers/
│ │ │ ├── filename.js
│ │ │ └── tags.js
│ │ ├── process-listener.js
│ │ ├── rerunUtil.js
│ │ ├── runner.js
│ │ ├── test-runners/
│ │ │ ├── cucumber/
│ │ │ │ ├── README.md
│ │ │ │ ├── _setup_cucumber_runner.js
│ │ │ │ └── nightwatch-format.js
│ │ │ ├── cucumber.js
│ │ │ ├── default.js
│ │ │ ├── mocha/
│ │ │ │ ├── custom-runnable.js
│ │ │ │ ├── custom-runner.js
│ │ │ │ ├── extensions.js
│ │ │ │ └── nightwatchSuite.js
│ │ │ └── mocha.js
│ │ └── test-source.js
│ ├── settings/
│ │ ├── defaults.js
│ │ └── settings.js
│ ├── testsuite/
│ │ ├── context.js
│ │ ├── globals.js
│ │ ├── hooks/
│ │ │ ├── _basehook.js
│ │ │ ├── afterAll.js
│ │ │ ├── afterChildProcess.js
│ │ │ ├── afterEach.js
│ │ │ ├── beforeAll.js
│ │ │ ├── beforeChildProcess.js
│ │ │ └── beforeEach.js
│ │ ├── hooks.js
│ │ ├── index.js
│ │ ├── interfaces/
│ │ │ ├── common.js
│ │ │ ├── describe.js
│ │ │ └── exports.js
│ │ ├── nightwatch-inspector/
│ │ │ ├── index.js
│ │ │ └── websocket-server.js
│ │ ├── repl.js
│ │ ├── retries.js
│ │ ├── runnable.js
│ │ └── testcase.js
│ ├── transport/
│ │ ├── errors/
│ │ │ └── index.js
│ │ ├── factory.js
│ │ ├── index.js
│ │ └── selenium-webdriver/
│ │ ├── actions.js
│ │ ├── appium.js
│ │ ├── appiumBase.js
│ │ ├── browserstack/
│ │ │ ├── appAutomate.js
│ │ │ ├── automate.js
│ │ │ ├── automateTurboScale.js
│ │ │ └── browserstack.js
│ │ ├── cdp.js
│ │ ├── chrome.js
│ │ ├── edge.js
│ │ ├── firefox.js
│ │ ├── httpclient.js
│ │ ├── index.js
│ │ ├── method-mappings.js
│ │ ├── options.js
│ │ ├── safari.js
│ │ ├── selenium.js
│ │ ├── service-builders/
│ │ │ ├── appium.js
│ │ │ ├── base-service.js
│ │ │ ├── chrome.js
│ │ │ ├── edge.js
│ │ │ ├── firefox.js
│ │ │ ├── safari.js
│ │ │ └── selenium.js
│ │ └── session.js
│ └── utils/
│ ├── addDetailedError.js
│ ├── alwaysDisplayError.js
│ ├── analytics.js
│ ├── beautifyStackTrace.js
│ ├── browsername.js
│ ├── chalkColors.js
│ ├── createPromise.js
│ ├── debuggability.js
│ ├── getAllClassMethodNames.js
│ ├── getFreePort.js
│ ├── index.js
│ ├── isErrorObject.js
│ ├── locatestrategy.js
│ ├── logger/
│ │ ├── index.js
│ │ └── log_settings.js
│ ├── mobile.js
│ ├── periodic-promise.js
│ ├── printVersionInfo.js
│ ├── requireModule.js
│ ├── safeStringify.js
│ ├── screenshots.js
│ ├── seleniumAtoms.js
│ ├── snapshots.js
│ ├── stackTrace.js
│ ├── timed-callback.js
│ └── version.js
├── package.json
├── test/
│ ├── .eslintrc
│ ├── apidemos/
│ │ ├── actions-api/
│ │ │ ├── actionsApi.js
│ │ │ └── asyncActionsApi.js
│ │ ├── angular-test/
│ │ │ ├── angularTodoListWithClassicApis.js
│ │ │ ├── angularTodoListWithElementGlobal.js
│ │ │ ├── angularTodoListWithElementGlobalAndError.js
│ │ │ └── angularTodoListWithElementGlobalAsync.js
│ │ ├── appium/
│ │ │ └── appiumTest.js
│ │ ├── cdp/
│ │ │ ├── registerAuth.js
│ │ │ └── registerAuth2.js
│ │ ├── chrome/
│ │ │ └── chromeTest.js
│ │ ├── cookies/
│ │ │ ├── cookieTests.js
│ │ │ └── cookieTestsWithError.js
│ │ ├── custom-commands/
│ │ │ ├── testNamespacedAliases.js
│ │ │ ├── testUsingAsyncCustomAssert.js
│ │ │ ├── testUsingAutoInvokeCommand.js
│ │ │ ├── testUsingCommandReturnFn.js
│ │ │ ├── testUsingCustomExecute.js
│ │ │ ├── testUsingCustomGetEmail.js
│ │ │ └── testUsingES6AsyncCustomCommands.js
│ │ ├── custom-commands-parallel/
│ │ │ └── testUsingES6AsyncCustomCommands.js
│ │ ├── elements/
│ │ │ ├── elementGlobalTest.js
│ │ │ ├── findElementsCustomCommand.js
│ │ │ ├── findElementsPageCommands.js
│ │ │ └── testGlobalLocateStrategy.js
│ │ ├── ensure/
│ │ │ ├── ensureTestError.js
│ │ │ ├── ensureTestNotSelected.js
│ │ │ └── ensureTestSelected.js
│ │ ├── expect-global/
│ │ │ ├── deepEqual.js
│ │ │ └── expect.js
│ │ ├── firefox/
│ │ │ └── firefoxTest.js
│ │ ├── namespaced-api/
│ │ │ └── namespacedApiTest.js
│ │ ├── navigation/
│ │ │ └── navigateTest.js
│ │ ├── page-objects/
│ │ │ └── commandsReturnTypeTest.js
│ │ ├── relative-locators/
│ │ │ └── sample-with-relative-locators.js
│ │ └── web-elements/
│ │ ├── assertionTest.js
│ │ ├── elementApiWithPageObjects.js
│ │ ├── waitUntilElementNotPresent.js
│ │ ├── waitUntilFailureTest.js
│ │ └── waitUntilTest.js
│ ├── asynchookstests/
│ │ ├── afterEach-timeout/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── async-provide-error/
│ │ │ ├── after.js
│ │ │ ├── afterAsync.js
│ │ │ ├── afterEach.js
│ │ │ ├── afterEachAsync.js
│ │ │ ├── afterEachWithClient.js
│ │ │ ├── afterWithClient.js
│ │ │ ├── before.js
│ │ │ ├── beforeAsync.js
│ │ │ ├── beforeEach.js
│ │ │ ├── beforeEachAsync.js
│ │ │ ├── beforeEachAsyncWithClient.js
│ │ │ ├── beforeEachAsyncWithClientMultiple.js
│ │ │ ├── beforeEachWithClient.js
│ │ │ └── beforeWithClient.js
│ │ ├── before-timeout/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── sampleWithAssertionFailedInAfter.js
│ │ ├── sampleWithAssertionFailedInBefore.js
│ │ ├── sampleWithErrorInTestcaseAndAfter.js
│ │ ├── sampleWithFailureInBeforeAndAfter.js
│ │ ├── sampleWithFailureInTestcaseAndAfter.js
│ │ ├── unittest-async-timeout.js
│ │ ├── unittest-error.js
│ │ └── unittest-failure/
│ │ └── unittest-failure.js
│ ├── common.js
│ ├── component-tests/
│ │ ├── samples/
│ │ │ ├── nightwatch.conf-noplugins.js
│ │ │ ├── react/
│ │ │ │ ├── nightwatch.conf.js
│ │ │ │ ├── src/
│ │ │ │ │ └── Form.jsx
│ │ │ │ └── tests/
│ │ │ │ ├── Form.spec--_with-$hooks.jsx
│ │ │ │ ├── formTest--notFound.js
│ │ │ │ └── formTest.js
│ │ │ └── vue/
│ │ │ ├── nightwatch.conf.js
│ │ │ ├── src/
│ │ │ │ └── Form.vue
│ │ │ └── tests/
│ │ │ ├── formTest--notFound.js
│ │ │ └── formTest.js
│ │ └── src/
│ │ ├── testRunBasicReact.js
│ │ ├── testRunBasicVue.js
│ │ └── testRunnJSXReact.js
│ ├── cucumber-integration-tests/
│ │ ├── sample_cucumber_tests/
│ │ │ ├── chainingCommands/
│ │ │ │ └── testCommands.js
│ │ │ ├── customCommands/
│ │ │ │ └── testCucumberWithCustomWait.js
│ │ │ ├── integration/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallel/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallel-formatters/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── parallelWithMultipleDefinition/
│ │ │ │ ├── testExpect.js
│ │ │ │ └── testSample.js
│ │ │ ├── with-extra-setup/
│ │ │ │ ├── _extra_setup.js
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ ├── with-modified-settings/
│ │ │ │ ├── plugin/
│ │ │ │ │ ├── index.js
│ │ │ │ │ └── nightwatch/
│ │ │ │ │ └── globals.js
│ │ │ │ └── testSample.js
│ │ │ ├── withexpect/
│ │ │ │ ├── sample.feature
│ │ │ │ ├── testSample.js
│ │ │ │ └── testWithFailures.js
│ │ │ └── withwaitFor/
│ │ │ ├── sample.feature
│ │ │ └── testWithFailures.js
│ │ ├── testCucumberTestsInParallel.js
│ │ ├── testCucumberTestsParallelFormatters.js
│ │ ├── testCucumberTestsWithExpect.js
│ │ ├── testCucumberTestsWithExtras.js
│ │ ├── testCucumberTestsWithModifiedSettings.js
│ │ └── testCucumberTestsWithWaitFor.js
│ ├── extra/
│ │ ├── assertions/
│ │ │ ├── .dotrc
│ │ │ ├── customAssertion.js
│ │ │ └── customAssertionWithSelector.js
│ │ ├── commands/
│ │ │ ├── _otherPerform.js
│ │ │ ├── autoInvoke/
│ │ │ │ └── customCommandInvoke.js
│ │ │ ├── customClearValue.js
│ │ │ ├── customCommand.js
│ │ │ ├── customCommandAppendResults.js
│ │ │ ├── customCommandConstructor.js
│ │ │ ├── customCommandWithFailure.js
│ │ │ ├── customCommandWithFailureClass.js
│ │ │ ├── customCommandWithSelector.js
│ │ │ ├── customElementPresent.js
│ │ │ ├── customExecute.js
│ │ │ ├── customPauseWithNamespacedAlias.js
│ │ │ ├── customPerform.js
│ │ │ ├── customQuit.js
│ │ │ ├── customWaitForPresent.js
│ │ │ ├── es6async/
│ │ │ │ ├── basicPerform.js
│ │ │ │ ├── basicPerformWithFluentApi.js
│ │ │ │ ├── customExecuteAsync.js
│ │ │ │ ├── customFindElements.js
│ │ │ │ ├── customFindElementsES6.js
│ │ │ │ ├── customPerform.js
│ │ │ │ ├── customPerformClass.js
│ │ │ │ ├── customVisible.js
│ │ │ │ └── getEmail.js
│ │ │ ├── other/
│ │ │ │ └── otherCommand.js
│ │ │ ├── returnFn/
│ │ │ │ └── customCommandReturnFn.js
│ │ │ └── typescript/
│ │ │ ├── tsWait.js
│ │ │ └── tsWait.ts
│ │ ├── cucumber-config-events.js
│ │ ├── cucumber-config-expect.js
│ │ ├── cucumber-config-noautostart.js
│ │ ├── cucumber-config-parallel-formatters.js
│ │ ├── cucumber-config-parallel.js
│ │ ├── cucumber-config-waitFor.js
│ │ ├── cucumber-config.js
│ │ ├── existing-custom-commands/
│ │ │ └── click.js
│ │ ├── external-globals-async.js
│ │ ├── external-globals.js
│ │ ├── globals-err.js
│ │ ├── globals.js
│ │ ├── minimalJsonReporter.json
│ │ ├── mock-errors/
│ │ │ └── sample-error.js
│ │ ├── nightwatch.json
│ │ ├── otherPageobjects/
│ │ │ └── otherPage.js
│ │ ├── package.json
│ │ ├── pageobjects/
│ │ │ ├── commands/
│ │ │ │ ├── commandsClassWithName.js
│ │ │ │ ├── common-commands.js
│ │ │ │ ├── helperCommandsClass.js
│ │ │ │ └── workingCommandsClass.js
│ │ │ └── pages/
│ │ │ ├── addl/
│ │ │ │ └── simplePageObject.js
│ │ │ ├── api/
│ │ │ │ └── method/
│ │ │ │ ├── bar.js
│ │ │ │ └── foo.js
│ │ │ ├── invalidPageObj.js
│ │ │ ├── pageObjElementsArray.js
│ │ │ ├── simplePageObj.js
│ │ │ ├── simplePageObjDefaultXpath.js
│ │ │ ├── simplePageObjWithCommandsClass.js
│ │ │ ├── simplePageObjWithCommandsClassThrowsError.js
│ │ │ ├── simplePageObjWithCommandsObject.js
│ │ │ ├── simplePageObjWithError.js
│ │ │ ├── waitForElementNotPresentPageObj.js
│ │ │ └── workingPageObjPlain.js
│ │ ├── parallelism-auto.json
│ │ ├── parallelism-count.json
│ │ ├── parallelism-customCommandsSync.json
│ │ ├── parallelism-disabled.json
│ │ ├── parallelism-envs.json
│ │ ├── parallelism-execArgv-selected.json
│ │ ├── parallelism-execArgv.json
│ │ ├── parallelism-selenium-server.json
│ │ ├── parallelism-workers.conf.js
│ │ ├── parallelism.json
│ │ ├── plugin/
│ │ │ ├── index.js
│ │ │ └── nightwatch/
│ │ │ ├── assertions/
│ │ │ │ └── customAssertion.js
│ │ │ ├── commands/
│ │ │ │ └── customCommand.js
│ │ │ └── globals.js
│ │ ├── reportObject.js
│ │ ├── reporter/
│ │ │ ├── custom.js
│ │ │ └── notvalid.js
│ │ ├── withgeckodriver-concurrent.json
│ │ ├── withmocha.json
│ │ └── withsafari-concurrent.json
│ ├── lib/
│ │ ├── command-mocks.js
│ │ ├── fakedriver.js
│ │ ├── globals/
│ │ │ ├── commands-w3c.js
│ │ │ ├── commands.js
│ │ │ └── expect.js
│ │ ├── globals.js
│ │ ├── mochatest.js
│ │ ├── mockclient.js
│ │ ├── mocks/
│ │ │ ├── api-loader/
│ │ │ │ ├── assertion-loader.js
│ │ │ │ └── assertion.js
│ │ │ ├── assertionLoader.js
│ │ │ ├── core/
│ │ │ │ ├── assertion.js
│ │ │ │ └── session.js
│ │ │ ├── mocks-jsonwire.yaml
│ │ │ └── mocks-w3c.yaml
│ │ ├── mocks.json
│ │ ├── mockserver.js
│ │ ├── nightwatch.js
│ │ ├── nocks.js
│ │ ├── nockselements.js
│ │ └── utils.js
│ ├── mocha.opts
│ ├── mochatests/
│ │ ├── async/
│ │ │ ├── sampleWithAsyncWithFailures.js
│ │ │ └── sampleWithBeforeAndAfter.js
│ │ └── integration/
│ │ ├── sampleWithAsyncTestcase.js
│ │ ├── sampleWithBeforeAndAfter.js
│ │ └── sampleWithFailures.js
│ ├── nightwatch.json
│ ├── sampletests/
│ │ ├── appendtestresult/
│ │ │ └── sampleWithAppendResults.js
│ │ ├── async/
│ │ │ └── test/
│ │ │ └── sample.js
│ │ ├── asyncwithexpectfailures/
│ │ │ └── sample.js
│ │ ├── asyncwithfailures/
│ │ │ ├── sampleWithAsyncWithFailures.js
│ │ │ ├── sampleWithAsyncWithSingleTestFailure.js
│ │ │ └── sampleWithBeforeAndAfter.js
│ │ ├── before-after/
│ │ │ ├── sampleSingleTest.js
│ │ │ ├── sampleWithBeforeAndAfter.js
│ │ │ ├── sampleWithBeforeAndAfterNoCallback.js
│ │ │ └── syncBeforeAndAfter.js
│ │ ├── beforewithcommand/
│ │ │ ├── commandInsideBefore.js
│ │ │ └── commandInsideBeforeWithNoParams.js
│ │ ├── empty/
│ │ │ └── .gitignore
│ │ ├── es6await/
│ │ │ ├── basicSampleTest.js
│ │ │ ├── incorrect-element-args/
│ │ │ │ └── sampleTestProperty.js
│ │ │ ├── selenium/
│ │ │ │ ├── basicSampleTestSelenium.js
│ │ │ │ ├── failures/
│ │ │ │ │ └── sampleWithFailures.js
│ │ │ │ └── getlog/
│ │ │ │ └── getLogTestES6.js
│ │ │ └── webdriver/
│ │ │ └── getText/
│ │ │ └── getTextES6.js
│ │ ├── isPresent/
│ │ │ └── elementNotPresent.js
│ │ ├── mixed/
│ │ │ └── sample.js
│ │ ├── mixed-files/
│ │ │ ├── sampleJs.js
│ │ │ └── sampleTs.ts
│ │ ├── passwordValueRedacted/
│ │ │ └── passwordValueRedacted.js
│ │ ├── reusebrowser/
│ │ │ ├── firstTest.js
│ │ │ └── secondTest.js
│ │ ├── sampleforreport/
│ │ │ ├── sample.js
│ │ │ └── sampleWithFailure.js
│ │ ├── simple/
│ │ │ └── test/
│ │ │ └── sample.js
│ │ ├── srcfolders/
│ │ │ └── other_sample.js
│ │ ├── suiteretries/
│ │ │ ├── locate-strategy/
│ │ │ │ └── suiteRetriesLocateStrategy.js
│ │ │ └── sample/
│ │ │ └── suiteRetriesSample.js
│ │ ├── syncnames/
│ │ │ └── sampleTest.js
│ │ ├── tags/
│ │ │ └── sample.js
│ │ ├── tagswithbrowserobject/
│ │ │ └── sample.js
│ │ ├── trace/
│ │ │ └── sample.js
│ │ ├── typescript/
│ │ │ └── sample.ts
│ │ ├── unittests/
│ │ │ ├── sample.js
│ │ │ └── sampleAnnotation.js
│ │ ├── unknown-method/
│ │ │ └── UnknownMethod.js
│ │ ├── usexpath/
│ │ │ └── sample.js
│ │ ├── usingwithin/
│ │ │ ├── testNoWithin.js
│ │ │ └── testWithin.js
│ │ ├── webelement/
│ │ │ └── findWithSuppressNotFoundErrors.js
│ │ ├── withaftereach/
│ │ │ └── sampleSingleTest.js
│ │ ├── withasynchooks/
│ │ │ └── sampleAsyncHooks.js
│ │ ├── withchaiexpect/
│ │ │ ├── sampleWithChai.js
│ │ │ └── sampleWithGlobalExpect.js
│ │ ├── withcommanderrors/
│ │ │ └── demoTest.js
│ │ ├── withcustomcommands/
│ │ │ ├── element/
│ │ │ │ └── withCustomElementCommand.js
│ │ │ ├── sampleWithAsyncFailures.js
│ │ │ └── sampleWithFailures.js
│ │ ├── withdescribe/
│ │ │ ├── basic/
│ │ │ │ ├── sample.js
│ │ │ │ └── sampleWithOnly.js
│ │ │ ├── basic2/
│ │ │ │ └── sample.js
│ │ │ ├── failures/
│ │ │ │ ├── sampleSkipTestcases.js
│ │ │ │ ├── sampleTest.js
│ │ │ │ └── sampleTestWithAttribute.js
│ │ │ ├── skipped/
│ │ │ │ ├── duplicateTestcases.js
│ │ │ │ ├── skipBeforeAfterEach.js
│ │ │ │ ├── skipTestcase.js
│ │ │ │ └── skipTestsuite.js
│ │ │ ├── suite-retries/
│ │ │ │ ├── sample.js
│ │ │ │ └── sampleWithAttribute.js
│ │ │ └── unittests/
│ │ │ └── sampleAnnotationWithDescribe.js
│ │ ├── withelementerrors/
│ │ │ └── sampleTestWithElementError.js
│ │ ├── witherrors/
│ │ │ └── sampleWithError.js
│ │ ├── withes6asynccommands/
│ │ │ └── sampleWithAsyncCommands.js
│ │ ├── withexclude/
│ │ │ ├── excluded/
│ │ │ │ ├── excluded-module.js
│ │ │ │ └── not-excluded.js
│ │ │ └── simple/
│ │ │ └── sample.js
│ │ ├── withfailures/
│ │ │ └── sample.js
│ │ ├── withpageobjects/
│ │ │ └── useXpathWithPageObjects.js
│ │ ├── withservererrors/
│ │ │ └── sampleTestWithServerError.js
│ │ ├── withsubfolders/
│ │ │ ├── simple/
│ │ │ │ └── sample.js
│ │ │ └── tags/
│ │ │ └── sampleTags.js
│ │ ├── withuknownRequire/
│ │ │ └── sample.js
│ │ ├── withuncaughterrors/
│ │ │ ├── demoTestFine.js
│ │ │ └── demoTestWithError.js
│ │ ├── withverify/
│ │ │ ├── verifySampleFailures.js
│ │ │ └── verifyWithinPerform.js
│ │ ├── withwait/
│ │ │ └── elementNotPresent.js
│ │ └── withwebdriver/
│ │ └── sampleTestUsingSeleniumWebdriver.js
│ ├── src/
│ │ ├── analytics/
│ │ │ └── testAnalytics.js
│ │ ├── api/
│ │ │ ├── assertions/
│ │ │ │ ├── testAttributeContains.js
│ │ │ │ ├── testAttributeEquals.js
│ │ │ │ ├── testAttributeMatches.js
│ │ │ │ ├── testContainsText.js
│ │ │ │ ├── testCssClassPresent.js
│ │ │ │ ├── testCssProperty.js
│ │ │ │ ├── testDomPropertyContains.js
│ │ │ │ ├── testDomPropertyEquals.js
│ │ │ │ ├── testDomPropertyMatches.js
│ │ │ │ ├── testElementPresent.js
│ │ │ │ ├── testElementsCount.js
│ │ │ │ ├── testEnabled.js
│ │ │ │ ├── testHasAttribute.js
│ │ │ │ ├── testHasClass.js
│ │ │ │ ├── testHidden.js
│ │ │ │ ├── testSelected.js
│ │ │ │ ├── testTextEquals.js
│ │ │ │ ├── testTextMatches.js
│ │ │ │ ├── testTitle.js
│ │ │ │ ├── testTitleContains.js
│ │ │ │ ├── testTitleEquals.js
│ │ │ │ ├── testTitleMatches.js
│ │ │ │ ├── testUrlContains.js
│ │ │ │ ├── testUrlEquals.js
│ │ │ │ ├── testUrlMatches.js
│ │ │ │ ├── testValue.js
│ │ │ │ ├── testValueContains.js
│ │ │ │ ├── testValueEquals.js
│ │ │ │ └── testVisible.js
│ │ │ ├── commands/
│ │ │ │ ├── client/
│ │ │ │ │ ├── testAxeCommands.js
│ │ │ │ │ ├── testCaptureNetworkRequests.js
│ │ │ │ │ ├── testEnablePerformanceMetrics.js
│ │ │ │ │ ├── testEnd.js
│ │ │ │ │ ├── testGetPerformanceMetrics.js
│ │ │ │ │ ├── testInit.js
│ │ │ │ │ ├── testLocateStrategy.js
│ │ │ │ │ ├── testMockNetworkResponse.js
│ │ │ │ │ ├── testNavigateTo.js
│ │ │ │ │ ├── testNightwatchRepl.js
│ │ │ │ │ ├── testPause.js
│ │ │ │ │ ├── testPerform.js
│ │ │ │ │ ├── testRegisterBasicAuth.js
│ │ │ │ │ ├── testSaveScreenshot.js
│ │ │ │ │ ├── testSaveSnapshot.js
│ │ │ │ │ ├── testSetDeviceDimensions.js
│ │ │ │ │ ├── testSetGeolocation.js
│ │ │ │ │ ├── testSetNetworkConditions.js
│ │ │ │ │ ├── testTakeHeapSnapshot.js
│ │ │ │ │ └── testWaitUntil.js
│ │ │ │ ├── cookies/
│ │ │ │ │ ├── testCookie.js
│ │ │ │ │ ├── testCookies.js
│ │ │ │ │ └── testCookiesErrors.js
│ │ │ │ ├── document/
│ │ │ │ │ ├── testExecute.js
│ │ │ │ │ ├── testInjectScript.js
│ │ │ │ │ └── testSource.js
│ │ │ │ ├── element/
│ │ │ │ │ ├── testCheck.js
│ │ │ │ │ ├── testClearValue.js
│ │ │ │ │ ├── testClick.js
│ │ │ │ │ ├── testClickAndHold.js
│ │ │ │ │ ├── testClickMobile.js
│ │ │ │ │ ├── testDoubleClick.js
│ │ │ │ │ ├── testDragAndDrop.js
│ │ │ │ │ ├── testGetAccessibleName.js
│ │ │ │ │ ├── testGetAriaRole.js
│ │ │ │ │ ├── testGetAttribute.js
│ │ │ │ │ ├── testGetAttributeW3c.js
│ │ │ │ │ ├── testGetCssProperty.js
│ │ │ │ │ ├── testGetElementProperty.js
│ │ │ │ │ ├── testGetElementRect.js
│ │ │ │ │ ├── testGetElementSize.js
│ │ │ │ │ ├── testGetFirstElementChild.js
│ │ │ │ │ ├── testGetLastElementChild.js
│ │ │ │ │ ├── testGetLocation.js
│ │ │ │ │ ├── testGetLocationInView.js
│ │ │ │ │ ├── testGetNextSibling.js
│ │ │ │ │ ├── testGetPreviousSibling.js
│ │ │ │ │ ├── testGetTagName.js
│ │ │ │ │ ├── testGetText.js
│ │ │ │ │ ├── testGetTitle.js
│ │ │ │ │ ├── testGetValue.js
│ │ │ │ │ ├── testHasDescendants.js
│ │ │ │ │ ├── testIsEnabled.js
│ │ │ │ │ ├── testIsPresent.js
│ │ │ │ │ ├── testIsSelected.js
│ │ │ │ │ ├── testIsVisible.js
│ │ │ │ │ ├── testMoveToElement.js
│ │ │ │ │ ├── testRightClick.js
│ │ │ │ │ ├── testSendKeys.js
│ │ │ │ │ ├── testSetAttribute.js
│ │ │ │ │ ├── testSetPassword.js
│ │ │ │ │ ├── testSetPasswordReport.js
│ │ │ │ │ ├── testSetValue.js
│ │ │ │ │ ├── testSubmitForm.js
│ │ │ │ │ ├── testTakeElementScreenshot.js
│ │ │ │ │ ├── testUncheck.js
│ │ │ │ │ ├── testUploadFile.js
│ │ │ │ │ ├── testWaitForElementNotPresent.js
│ │ │ │ │ ├── testWaitForElementNotVisible.js
│ │ │ │ │ ├── testWaitForElementPresent.js
│ │ │ │ │ └── testWaitForElementVisible.js
│ │ │ │ ├── logs/
│ │ │ │ │ ├── testCaptureBrowserConsoleLogs.js
│ │ │ │ │ ├── testCaptureBrowserExceptions.js
│ │ │ │ │ ├── testGetLog.js
│ │ │ │ │ ├── testGetLogTypes.js
│ │ │ │ │ └── testIsLogAvailable.js
│ │ │ │ ├── testPageSource.js
│ │ │ │ ├── testSendKeys.js
│ │ │ │ ├── testUpdateValue.js
│ │ │ │ ├── web-element/
│ │ │ │ │ ├── assert/
│ │ │ │ │ │ └── testElementAssertions.js
│ │ │ │ │ ├── testCheck.js
│ │ │ │ │ ├── testClear.js
│ │ │ │ │ ├── testClick.js
│ │ │ │ │ ├── testClickAndHold.js
│ │ │ │ │ ├── testDoubleClick.js
│ │ │ │ │ ├── testDragAndDrop.js
│ │ │ │ │ ├── testElement.js
│ │ │ │ │ ├── testFind.js
│ │ │ │ │ ├── testFindAll.js
│ │ │ │ │ ├── testFindAllByAltText.js
│ │ │ │ │ ├── testFindAllByPlaceholderText.js
│ │ │ │ │ ├── testFindAllByRole.js
│ │ │ │ │ ├── testFindAllByText.js
│ │ │ │ │ ├── testFindByAltText.js
│ │ │ │ │ ├── testFindByLabelText.js
│ │ │ │ │ ├── testFindByPlaceholderText.js
│ │ │ │ │ ├── testFindByRole.js
│ │ │ │ │ ├── testFindByText.js
│ │ │ │ │ ├── testFindOnErrors.js
│ │ │ │ │ ├── testGetAccessibleName.js
│ │ │ │ │ ├── testGetAriaRole.js
│ │ │ │ │ ├── testGetAttribute.js
│ │ │ │ │ ├── testGetCssProperty.js
│ │ │ │ │ ├── testGetFirstElementChild.js
│ │ │ │ │ ├── testGetId.js
│ │ │ │ │ ├── testGetLastElementChild.js
│ │ │ │ │ ├── testGetNextElementSibling.js
│ │ │ │ │ ├── testGetPreviousElementSibling.js
│ │ │ │ │ ├── testGetProperty.js
│ │ │ │ │ ├── testGetRect.js
│ │ │ │ │ ├── testGetShadowRoot.js
│ │ │ │ │ ├── testGetTagName.js
│ │ │ │ │ ├── testGetText.js
│ │ │ │ │ ├── testGetValue.js
│ │ │ │ │ ├── testIsActive.js
│ │ │ │ │ ├── testIsEnabled.js
│ │ │ │ │ ├── testIsPresent.js
│ │ │ │ │ ├── testIsSelected.js
│ │ │ │ │ ├── testIsVisible.js
│ │ │ │ │ ├── testMoveTo.js
│ │ │ │ │ ├── testRightClick.js
│ │ │ │ │ ├── testSendKeys.js
│ │ │ │ │ ├── testSetAttribute.js
│ │ │ │ │ ├── testSetProperty.js
│ │ │ │ │ ├── testSetValue.js
│ │ │ │ │ ├── testShadowFind.js
│ │ │ │ │ ├── testShadowFindAll.js
│ │ │ │ │ ├── testSubmit.js
│ │ │ │ │ ├── testTakeScreenshot.js
│ │ │ │ │ ├── testUncheck.js
│ │ │ │ │ ├── testUpdate.js
│ │ │ │ │ └── testUpload.js
│ │ │ │ └── window/
│ │ │ │ ├── testCloseWindow.js
│ │ │ │ ├── testMaximizeWindow.js
│ │ │ │ ├── testWindowCommands.js
│ │ │ │ ├── testWindowCommandsW3C.js
│ │ │ │ └── testWindowNamespaceCommands.js
│ │ │ ├── expect/
│ │ │ │ ├── testExpectActive.js
│ │ │ │ ├── testExpectAttribute.js
│ │ │ │ ├── testExpectCookie.js
│ │ │ │ ├── testExpectCount.js
│ │ │ │ ├── testExpectCss.js
│ │ │ │ ├── testExpectEnabled.js
│ │ │ │ ├── testExpectPresent.js
│ │ │ │ ├── testExpectProperty.js
│ │ │ │ ├── testExpectSelected.js
│ │ │ │ ├── testExpectText.js
│ │ │ │ ├── testExpectTitle.js
│ │ │ │ ├── testExpectType.js
│ │ │ │ ├── testExpectUrl.js
│ │ │ │ ├── testExpectValue.js
│ │ │ │ └── testExpectVisible.js
│ │ │ ├── expect-global/
│ │ │ │ ├── testElementAttribute.js
│ │ │ │ ├── testElementCss.js
│ │ │ │ ├── testElementIsDisplayed.js
│ │ │ │ ├── testElementIsEnabled.js
│ │ │ │ ├── testElementIsSelected.js
│ │ │ │ ├── testElementProperty.js
│ │ │ │ └── testElementText.js
│ │ │ └── protocol/
│ │ │ ├── testActivity.js
│ │ │ ├── testAlerts.js
│ │ │ ├── testBrowserCommands.js
│ │ │ ├── testChrome.js
│ │ │ ├── testContext.js
│ │ │ ├── testCookies.js
│ │ │ ├── testDoubleClick.js
│ │ │ ├── testElementCommands.js
│ │ │ ├── testEnsure.js
│ │ │ ├── testFirefox.js
│ │ │ ├── testFrame.js
│ │ │ ├── testFrameCommand.js
│ │ │ ├── testGeolocation.js
│ │ │ ├── testKeyboardInteraction.js
│ │ │ ├── testKeys.js
│ │ │ ├── testLog.js
│ │ │ ├── testMouseButtonClick.js
│ │ │ ├── testMoveTo.js
│ │ │ ├── testOrientation.js
│ │ │ ├── testReleaseMouseButton.js
│ │ │ ├── testResetApp.js
│ │ │ ├── testScreenshot.js
│ │ │ ├── testSendKeys.js
│ │ │ ├── testSession.js
│ │ │ ├── testSetValue.js
│ │ │ ├── testSource.js
│ │ │ ├── testStatus.js
│ │ │ ├── testSubmit.js
│ │ │ ├── testTimeouts.js
│ │ │ ├── testTitle.js
│ │ │ ├── testUploadFile.js
│ │ │ ├── testUrl.js
│ │ │ ├── testWindowCommands.js
│ │ │ ├── testWindowPosition.js
│ │ │ ├── testWindowRect.js
│ │ │ └── testWindowSize.js
│ │ ├── apidemos/
│ │ │ ├── actions-api/
│ │ │ │ ├── asyncPerformActionsTest.js
│ │ │ │ └── performActionsTest.js
│ │ │ ├── angular-test/
│ │ │ │ └── runAngularDemo.js
│ │ │ ├── appium/
│ │ │ │ └── testAppiumAPI.js
│ │ │ ├── cdp/
│ │ │ │ └── testCdpCommands.js
│ │ │ ├── chrome/
│ │ │ │ └── testChromeAPI.js
│ │ │ ├── cookies/
│ │ │ │ └── testCookieCommands.js
│ │ │ ├── custom-commands/
│ │ │ │ ├── testCustomCommandAutoInvoke.js
│ │ │ │ ├── testCustomCommandSync.js
│ │ │ │ ├── testCustomCommandsAsync.js
│ │ │ │ ├── testCustomExecuteAsync.js
│ │ │ │ └── testCustomPauseWithNamespacedAlias.js
│ │ │ ├── elements/
│ │ │ │ ├── testElementGlobal.js
│ │ │ │ ├── testFindElementsEs6CustomCommand.js
│ │ │ │ └── testFindElementsWithPageCommand.js
│ │ │ ├── ensure/
│ │ │ │ └── testEnsure.js
│ │ │ ├── expect-global/
│ │ │ │ └── testExpect.js
│ │ │ ├── firefox/
│ │ │ │ └── testFirefoxAPI.js
│ │ │ ├── namespaced-api/
│ │ │ │ └── testNamespacedApi.js
│ │ │ ├── navigation/
│ │ │ │ └── testNavigationCommands.js
│ │ │ ├── page-objects/
│ │ │ │ └── testCommandsReturnType.js
│ │ │ ├── relative-locators/
│ │ │ │ └── testWithRelativeLocators.js
│ │ │ └── web-elements/
│ │ │ ├── testAssert.js
│ │ │ ├── testElementApiWithPageObjects.js
│ │ │ └── testWaitUntil.js
│ │ ├── cli/
│ │ │ ├── testCliRunner.js
│ │ │ ├── testCliRunnerGenerate.js
│ │ │ ├── testCliRunnerMocha.js
│ │ │ ├── testDemoTypescriptFile.js
│ │ │ ├── testParallelExecution.js
│ │ │ ├── testParallelExecutionExitCode.js
│ │ │ └── testServiceCreationFromCli.js
│ │ ├── core/
│ │ │ ├── testAsyncTree.js
│ │ │ ├── testCreateSession.js
│ │ │ ├── testPageObjectApi.js
│ │ │ ├── testPageObjectCommands.js
│ │ │ ├── testPageObjectCustomCommands.js
│ │ │ ├── testPageObjectWaitForElementNotPresent.js
│ │ │ ├── testPlugins.js
│ │ │ ├── testQueue.js
│ │ │ ├── testRequestWithCredentials.js
│ │ │ └── testTreeNode.js
│ │ ├── element/
│ │ │ ├── testCommandsElementSelectors.js
│ │ │ ├── testElementCommands.js
│ │ │ ├── testExpectElementSelectors.js
│ │ │ ├── testIndexedElementSelectors.js
│ │ │ ├── testPageObjectElementSelectors-use_xpath.js
│ │ │ ├── testPageObjectElementSelectors.js
│ │ │ └── testProtocolElementSelectors.js
│ │ ├── globals.js
│ │ ├── index/
│ │ │ ├── testDefaultPathPrefixOption.js
│ │ │ ├── testMobileComponent.js
│ │ │ ├── testNightwatchIndex.js
│ │ │ ├── testProgrammaticApis.js
│ │ │ ├── testRequest.js
│ │ │ ├── testRequestTimeout.js
│ │ │ ├── testRunProtocolAction.js
│ │ │ ├── testSettings.js
│ │ │ └── transport/
│ │ │ ├── testAppiumTransport.js
│ │ │ ├── testBrowserstackTransport.js
│ │ │ ├── testChromeOptions.js
│ │ │ ├── testCreateTransport.js
│ │ │ ├── testEdgeOptions.js
│ │ │ ├── testFirefoxOptions.js
│ │ │ ├── testIeOptions.js
│ │ │ ├── testMobileOptions.js
│ │ │ ├── testMobileWebSupport.js
│ │ │ ├── testSafariOptions.js
│ │ │ └── testSeleniumTransport.js
│ │ ├── runner/
│ │ │ ├── cli/
│ │ │ │ └── testCliRunnerParallel.js
│ │ │ ├── cucumber-integration/
│ │ │ │ ├── testCliArgs.js
│ │ │ │ ├── testCucumberSampleTests.js
│ │ │ │ └── testCucumberWithBrowserstack.js
│ │ │ ├── mocha/
│ │ │ │ ├── testMochaRunnerAsync.js
│ │ │ │ └── testMochaRunnerIntegration.js
│ │ │ ├── testEventReporter.js
│ │ │ ├── testInspectorExtension.js
│ │ │ ├── testReporter.js
│ │ │ ├── testRerunFunctionality.js
│ │ │ ├── testRunBrowserstackTransport.js
│ │ │ ├── testRunTestcase.js
│ │ │ ├── testRunTestsuite.js
│ │ │ ├── testRunTestsuiteWithSuiteRetries.js
│ │ │ ├── testRunWithCommandErrors.js
│ │ │ ├── testRunWithCustomCommands.js
│ │ │ ├── testRunWithExclude.js
│ │ │ ├── testRunWithExistingCommands.js
│ │ │ ├── testRunWithExternalGlobals.js
│ │ │ ├── testRunWithGlobalHooks.js
│ │ │ ├── testRunWithGlobalReporter.js
│ │ │ ├── testRunWithHooks.js
│ │ │ ├── testRunWithMultipleSources.js
│ │ │ ├── testRunWithServerErrors.js
│ │ │ ├── testRunWithTags.js
│ │ │ ├── testRunWithVerify.js
│ │ │ ├── testRunner.js
│ │ │ ├── testRunnerChaiExpect.js
│ │ │ ├── testRunnerEndSessionOnFail.js
│ │ │ ├── testRunnerEs6Async.js
│ │ │ ├── testRunnerHtmlOutput.js
│ │ │ ├── testRunnerJsonOutput.js
│ │ │ ├── testRunnerJunitOutput.js
│ │ │ ├── testRunnerMixedFiles.js
│ │ │ ├── testRunnerRerunJsonOutput.js
│ │ │ ├── testRunnerScreenshotsOutput.js
│ │ │ ├── testRunnerSessionCreate.js
│ │ │ ├── testRunnerTypeScript.js
│ │ │ ├── testRunnerUncaughtErrors.js
│ │ │ ├── testRunnerUnitTests.js
│ │ │ ├── testRunnerUsingWithin.js
│ │ │ ├── testRunnerWithAsyncAssertionFailure.js
│ │ │ ├── testRunnerWithPageObjects.js
│ │ │ ├── testRunnerWithTrace.js
│ │ │ └── testTagsMatcher.js
│ │ ├── service-builders/
│ │ │ ├── testAppiumServer.js
│ │ │ ├── testChromeDriver.js
│ │ │ ├── testEdgeDriver.js
│ │ │ ├── testFirefoxDriver.js
│ │ │ ├── testSafariDriver.js
│ │ │ └── testSeleniumServer.js
│ │ └── utils/
│ │ ├── __data__/
│ │ │ ├── meaning-of-life.js
│ │ │ ├── meaning-of-life.mjs
│ │ │ ├── mixed-exports.mjs
│ │ │ └── named-exports.mjs
│ │ ├── testRequireModule.js
│ │ ├── testStackTrace.js
│ │ └── testUtils.js
│ ├── tsconfig.json
│ └── typescript-tests/
│ ├── demo.ts
│ └── tsconfig.nightwatch.json
└── types/
├── assertions.d.ts
├── chrome-options.d.ts
├── custom-assertion.d.ts
├── custom-command.d.ts
├── desired-capabilities.d.ts
├── expect.d.ts
├── globals.d.ts
├── index.d.ts
├── nightwatch-options.d.ts
├── page-object.d.ts
├── tests/
│ ├── actions.test-d.ts
│ ├── appiumCommands.test-d.ts
│ ├── chromiumClientCommands.test-d.ts
│ ├── clientCommands.test-d.ts
│ ├── component.test-d.ts
│ ├── customCommands.test-d.ts
│ ├── describe.test-d.ts
│ ├── elementCommands.test-d.ts
│ ├── expect.test-d.ts
│ ├── globalElementApi.test-d.ts
│ ├── index.test-d.ts
│ ├── namespaceCommands.test-d.ts
│ ├── page-object.test-d.ts
│ ├── programmaticApi.test-d.ts
│ ├── tsconfig.json
│ ├── webElement.test-d.ts
│ └── webdriverProtocolCommands.test-d.ts
├── utils.d.ts
└── web-element.d.ts
Showing preview only (311K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4183 symbols across 627 files)
FILE: examples/custom-commands/angular/getElementsInList.js
method command (line 2) | async command(listName, cb = function(r) {return r}) {
FILE: examples/globalsModule.js
method before (line 46) | before(cb) {
method beforeEach (line 51) | beforeEach(browser, cb) {
method after (line 56) | after(cb) {
method afterEach (line 61) | afterEach(browser, cb) {
method reporter (line 68) | reporter(results, cb) {
FILE: examples/pages/google/consent.js
class ConsentCommand (line 1) | class ConsentCommand {
method turnOffSearchCustomization (line 2) | turnOffSearchCustomization() {
method turnOffYoutubeHistory (line 8) | turnOffYoutubeHistory() {
method turnOffAdPersonalization (line 14) | turnOffAdPersonalization() {
method confirm (line 20) | confirm() {
method turnOffEverything (line 26) | turnOffEverything() {
FILE: examples/pages/google/search.js
method submit (line 2) | submit() {
FILE: examples/test-app/globals.js
method before (line 9) | before(done) {
method after (line 24) | after() {
FILE: examples/tests/selectElement.js
method before (line 4) | before(browser) {
method demoTest (line 8) | async demoTest(browser) {
FILE: lib/api/_loaders/_base-loader.js
class BaseLoader (line 9) | class BaseLoader extends EventEmitter {
method commandOverrides (line 10) | static get commandOverrides () {
method handleModuleError (line 22) | static handleModuleError(err, fullPath) {
method unflattenNamespace (line 38) | static unflattenNamespace(target, namespace, value) {
method createDriverCommand (line 50) | static createDriverCommand(nightwatchInstance, commandName) {
method lastDeferred (line 65) | static get lastDeferred() {
method lastDeferred (line 69) | static set lastDeferred(value) {
method commandQueue (line 73) | get commandQueue() {
method loadSubDirectories (line 77) | get loadSubDirectories() {
method reporter (line 81) | get reporter() {
method api (line 85) | get api() {
method elementLocator (line 89) | get elementLocator() {
method transport (line 93) | get transport() {
method namespace (line 97) | get namespace() {
method module (line 101) | get module() {
method module (line 105) | set module(val) {
method commandName (line 109) | get commandName() {
method commandFn (line 113) | get commandFn() {
method commandFn (line 117) | set commandFn(val) {
method commandName (line 121) | set commandName(val) {
method stackTrace (line 125) | set stackTrace(val) {
method stackTrace (line 129) | get stackTrace() {
method instance (line 133) | get instance() {
method isUserDefined (line 137) | get isUserDefined() {
method isUserDefined (line 141) | set isUserDefined(val) {
method addedInsideCallback (line 145) | get addedInsideCallback() {
method addedInsideCallback (line 149) | set addedInsideCallback(val) {
method ignoreUnderscoreLeadingNames (line 153) | set ignoreUnderscoreLeadingNames(val) {
method ignoreUnderscoreLeadingNames (line 157) | get ignoreUnderscoreLeadingNames() {
method constructor (line 161) | constructor(nightwatchInstance) {
method isTypescriptDisabled (line 168) | isTypescriptDisabled() {
method settings (line 172) | get settings() {
method getTargetNamespace (line 176) | getTargetNamespace() {
method isFileNameValid (line 180) | isFileNameValid(fileName) {
method setNamespace (line 188) | setNamespace(val) {
method loadModule (line 194) | loadModule(dirPath, fileName) {
method requireModule (line 205) | requireModule(fullPath, fileName) {
method loadModuleAsync (line 224) | async loadModuleAsync(dirPath, fileName) {
method requireModuleAsync (line 233) | async requireModuleAsync(fullPath, fileName) {
method validateMethod (line 252) | validateMethod() {}
method defineArgs (line 254) | defineArgs(parent, namespacedApi) {
method getNamespacedAliases (line 307) | getNamespacedAliases() {
method define (line 323) | define(parent = null) {
method defineNamespacedApi (line 351) | defineNamespacedApi(parent) {
method getCommandOptions (line 384) | getCommandOptions() {
method createQueuedCommandFn (line 388) | createQueuedCommandFn({parent, commandName, namespace, commandFn, cont...
method loadDriverCommands (line 488) | loadDriverCommands({commands, namespace}) {
FILE: lib/api/_loaders/_command-loader.js
class BaseCommandLoader (line 4) | class BaseCommandLoader extends BaseLoader {
method constructor (line 5) | constructor(nightwatchInstance) {
method isTypeImplemented (line 19) | static isTypeImplemented(instance, method, type) {
method sessionId (line 29) | get sessionId() {
method getCommandOptions (line 33) | getCommandOptions() {
method validateMethod (line 43) | validateMethod(parent) {
method resolveElementSelector (line 65) | resolveElementSelector(args) {
method getTargetNamespace (line 79) | getTargetNamespace(parent) {
FILE: lib/api/_loaders/assertion-scheduler.js
class AssertionScheduler (line 6) | class AssertionScheduler {
method instance (line 7) | get instance() {
method opts (line 11) | get opts() {
method constructor (line 19) | constructor(instance, opts = {}) {
method reschedule (line 28) | reschedule() {
method setOptsFromSelector (line 35) | setOptsFromSelector() {
method createAssertionRunner (line 49) | createAssertionRunner({passed, actual, commandCallback, message, elaps...
method verifyCommandArgs (line 67) | verifyCommandArgs() {
method start (line 75) | start() {
method schedule (line 82) | schedule() {
method getFullMessage (line 165) | getFullMessage(passed, elapsedTime) {
FILE: lib/api/_loaders/assertion.js
class AssertionLoader (line 9) | class AssertionLoader extends BaseCommandLoader {
method interfaceMethods (line 10) | static get interfaceMethods() {
method validateAssertClass (line 18) | static validateAssertClass(instance) {
method constructor (line 29) | constructor(nightwatchInstance) {
method timeout (line 37) | get timeout() {
method rescheduleInterval (line 41) | get rescheduleInterval() {
method globals (line 45) | get globals() {
method containsES6Class (line 49) | containsES6Class() {
method validateModuleDefinition (line 53) | validateModuleDefinition() {
method validateCJSModule (line 61) | validateCJSModule() {
method validateES6Class (line 67) | validateES6Class() {
method createQueuedCommandFn (line 73) | createQueuedCommandFn({parent, apiToReturn}) {
method createWrapper (line 129) | createWrapper(abortOnFailure) {
FILE: lib/api/_loaders/chrome.js
class ChromeCommandLoader (line 3) | class ChromeCommandLoader extends BaseLoader {
method chromeCommands (line 4) | static get chromeCommands() {
method loadCommands (line 22) | loadCommands() {
FILE: lib/api/_loaders/command.js
class CommandLoader (line 5) | class CommandLoader extends BaseCommandLoader {
method interfaceMethods (line 7) | static get interfaceMethods() {
method isDeprecatedCommandStyle (line 13) | static isDeprecatedCommandStyle(CommandModule) {
method createFromObject (line 23) | static createFromObject(CommandModule) {
method transportActions (line 39) | static transportActions({actions, api}) {
method createInstance (line 70) | static createInstance(nightwatchInstance, CommandModule, opts) {
method loadSubDirectories (line 148) | get loadSubDirectories() {
method createWrapper (line 152) | createWrapper() {
method getTargetNamespace (line 263) | getTargetNamespace(parent, namespacedApi) {
FILE: lib/api/_loaders/element-api.js
class ScopedElementAPILoader (line 6) | class ScopedElementAPILoader {
method availableElementCommands (line 7) | static get availableElementCommands() {
method isScopedElementCommand (line 24) | static isScopedElementCommand(commandName) {
method constructor (line 30) | constructor(nightwatchInstance) {
method createLocatingCommand (line 34) | createLocatingCommand(name) {
method loadElementMethods (line 42) | loadElementMethods(target, element) {
method createElementMethod (line 66) | createElementMethod() {
FILE: lib/api/_loaders/element-command.js
class ElementCommandLoader (line 4) | class ElementCommandLoader extends CommandLoader {
method createInstance (line 5) | static createInstance(CommandModule, opts) {
method createWrapper (line 11) | createWrapper() {
FILE: lib/api/_loaders/element-global.js
class ElementGlobal (line 10) | class ElementGlobal {
method availableElementCommands (line 11) | static get availableElementCommands() {
method element (line 35) | static element({locator, testSuite, client, options}) {
method api (line 42) | get api() {
method reporter (line 46) | get reporter() {
method commandQueue (line 50) | get commandQueue() {
method transport (line 54) | get transport() {
method settings (line 58) | get settings() {
method constructor (line 62) | constructor({testSuite, client, options = {}}) {
method init (line 74) | init() {
method findElement (line 78) | async findElement() {
method isElementObject (line 93) | static isElementObject(element) {
method setPropertiesFromElement (line 109) | setPropertiesFromElement(element) {
method createWebElement (line 135) | createWebElement(id) {
method setLocator (line 139) | setLocator(locator) {
method exported (line 173) | exported() {
method computeArguments (line 181) | computeArguments(args, commandName) {
method getComponentProperty (line 204) | getComponentProperty(propName) {
method createCommand (line 226) | createCommand(commandName, commandToExecute, nightwatchName) {
method setElement (line 330) | async setElement(stackTrace) {
method loadCommandsOntoObject (line 351) | loadCommandsOntoObject(exportedElement) {
FILE: lib/api/_loaders/ensure.js
class SeleniumCommand (line 12) | class SeleniumCommand extends EventEmitter {
method constructor (line 13) | constructor({negate, args, settings, commandName}) {
method setExpected (line 27) | setExpected() {
method isElementCommand (line 32) | isElementCommand() {
method requiresLocatingElement (line 36) | requiresLocatingElement() {
method getVerb (line 40) | getVerb() {
method getMessage (line 56) | getMessage(passed) {
method isSeleniumElement (line 75) | static isSeleniumElement(element) {
method adaptElementArgument (line 79) | async adaptElementArgument(transport) {
method execute (line 94) | async execute(transport) {
class EnsureAssertionLoader (line 103) | class EnsureAssertionLoader extends BaseLoader {
method defaultVerb (line 104) | static get defaultVerb() {
method assertOperators (line 108) | static get assertOperators() {
method elementCommands (line 133) | static get elementCommands() {
method requiresLocating (line 150) | static get requiresLocating() {
method runAssertion (line 165) | async runAssertion({negate, args, commandName, abortOnFailure, assertF...
method createAssertion (line 210) | createAssertion(commandName, abortOnFailure) {
method loadAssertions (line 256) | loadAssertions(parent = null) {
FILE: lib/api/_loaders/expect-assertion.js
class ExpectAssertionLoader (line 4) | class ExpectAssertionLoader extends BaseLoader {
method ChaiAssertionType (line 5) | static get ChaiAssertionType() {
method getChaiAssertionType (line 12) | static getChaiAssertionType(assertionType) {
method createMatcher (line 24) | static createMatcher({
method loadAssertion (line 57) | loadAssertion(expectCommandName) {
FILE: lib/api/_loaders/expect.js
class ExpectLoader (line 8) | class ExpectLoader extends BaseCommandLoader {
method interfaceMethods (line 9) | static get interfaceMethods() {
method createInstance (line 15) | static createInstance(nightwatchInstance, CommandModule, opts) {
method createWrapper (line 32) | createWrapper(abortOnFailure) {
method define (line 83) | define(parent = null) {
method loadAssertions (line 123) | loadAssertions(expectCommand) {
FILE: lib/api/_loaders/firefox.js
class FirefoxCommandLoader (line 3) | class FirefoxCommandLoader extends BaseLoader {
method firefoxCommands (line 4) | static get firefoxCommands() {
method loadCommands (line 13) | loadCommands() {
FILE: lib/api/_loaders/page-object.js
class PageObjectLoader (line 7) | class PageObjectLoader extends BaseLoader {
method loadSubDirectories (line 8) | get loadSubDirectories() {
method pageObjectCache (line 12) | get pageObjectCache() {
method loadApiCommands (line 16) | static loadApiCommands(nightwatchInstance) {
method loadApi (line 45) | loadApi(pageObject) {
method createWrapper (line 51) | createWrapper() {
method pageObjectDefinition (line 55) | pageObjectDefinition() {
method define (line 59) | define() {
FILE: lib/api/_loaders/plugin.js
method plugins (line 9) | static get plugins() {
method load (line 14) | static load(pluginName) {
FILE: lib/api/_loaders/static.js
method assertOperators (line 15) | static get assertOperators() {
method lastDeferred (line 33) | static get lastDeferred() {
method lastDeferred (line 37) | static set lastDeferred(value) {
method api (line 41) | get api() {
method reporter (line 45) | get reporter() {
method commandQueue (line 49) | get commandQueue() {
method constructor (line 53) | constructor(nightwatchInstance) {
method createStaticAssertion (line 65) | createStaticAssertion(commandName, abortOnFailure, apiToReturn) {
method loadStaticAssertions (line 202) | loadStaticAssertions(parent = null) {
method loadStaticExpect (line 256) | loadStaticExpect(parent = null) {
method addToQueue (line 292) | addToQueue() {
FILE: lib/api/_loaders/within-context.js
class WithinLoader (line 9) | class WithinLoader extends BaseLoader {
method loadSubDirectories (line 10) | get loadSubDirectories() {
method loadCommandCache (line 14) | static loadCommandCache(nightwatchInstance) {
method loadApi (line 38) | loadApi(context) {
method createWrapper (line 64) | createWrapper() {
method withinDefinition (line 68) | withinDefinition(...args) {
method define (line 78) | define() {
class WithinContext (line 83) | class WithinContext {
method api (line 85) | get api() {
method client (line 89) | get client() {
method args (line 93) | get args() {
method constructor (line 97) | constructor(loadApi, nightwatchInstance, container) {
FILE: lib/api/assertions/_assertionInstance.js
class AssertionInstance (line 8) | class AssertionInstance {
method isElementNotFoundResult (line 9) | static isElementNotFoundResult(result) {
method init (line 23) | static init({nightwatchInstance, args, fileName, options}) {
method constructor (line 41) | constructor({nightwatchInstance, args, fileName, options} = {}, skipIn...
method initialize (line 48) | initialize() {
method options (line 73) | set options(val) {
method options (line 77) | get options() {
method result (line 81) | get result() {
method args (line 85) | set args(value) {
method elementSelector (line 89) | set elementSelector(value) {
method api (line 93) | set api(value) {
method args (line 97) | get args() {
method negate (line 101) | get negate() {
method client (line 108) | get client() {
method api (line 112) | get api() {
method doneCallback (line 116) | get doneCallback() {
method doneCallback (line 120) | set doneCallback(value) {
method elementSelector (line 124) | get elementSelector() {
method runFailure (line 146) | runFailure() {
method hasFailure (line 156) | hasFailure() {
method getValue (line 170) | getValue() {
method isOk (line 187) | isOk(value = '') {
method getActual (line 202) | getActual() {
method setResult (line 221) | setResult(result) {
FILE: lib/api/assertions/domPropertyContains.js
method verb (line 30) | verb(negate) {
FILE: lib/api/assertions/domPropertyEquals.js
function formatMsg (line 27) | function formatMsg({msg, domProperty, expected, verb = function(negate) ...
method verb (line 52) | verb(negate) {
FILE: lib/api/assertions/hidden.js
constant MSG_ELEMENT_NOT_FOUND (line 17) | const MSG_ELEMENT_NOT_FOUND = 'Testing if element %s is hidden. ' +
FILE: lib/api/client-commands/_base-command.js
method isTraceable (line 2) | static get isTraceable() {
method makePromise (line 14) | static makePromise({performAction, userSuppliedCallback = function() {},...
method returnsFullResultObject (line 51) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 55) | get resolvesWithFullResultObject() {
method reportProtocolErrors (line 59) | reportProtocolErrors(result) {
method command (line 63) | command(userSuppliedCallback) {
method executeScriptHandler (line 83) | executeScriptHandler(method, script, args, callback) {
FILE: lib/api/client-commands/_locateStrategy.js
class Command (line 3) | class Command extends EventEmitter {
method command (line 4) | command(callback = function() {}) {
FILE: lib/api/client-commands/alerts/accept.js
class AcceptAlert (line 29) | class AcceptAlert extends ClientCommand {
method isTraceable (line 30) | static get isTraceable() {
method performAction (line 34) | performAction(callback) {
FILE: lib/api/client-commands/alerts/dismiss.js
class DismissAlert (line 32) | class DismissAlert extends ClientCommand {
method isTraceable (line 33) | static get isTraceable() {
method performAction (line 37) | performAction(callback) {
FILE: lib/api/client-commands/alerts/getText.js
class GetAlertText (line 31) | class GetAlertText extends ClientCommand {
method performAction (line 32) | performAction(callback) {
FILE: lib/api/client-commands/alerts/setText.js
class SetAlertText (line 30) | class SetAlertText extends ClientCommand {
method isTraceable (line 31) | static get isTraceable() {
method performAction (line 35) | performAction(callback) {
method command (line 41) | command(value, callback) {
FILE: lib/api/client-commands/axeInject.js
method allowOverride (line 25) | static get allowOverride() {
FILE: lib/api/client-commands/axeRun.js
method allowOverride (line 27) | static get allowOverride() {
FILE: lib/api/client-commands/cookies/delete.js
class DeleteCookie (line 30) | class DeleteCookie extends ClientCommand {
method isTraceable (line 31) | static get isTraceable() {
method performAction (line 35) | performAction(callback) {
method command (line 41) | command(cookieName, callback) {
FILE: lib/api/client-commands/cookies/deleteAll.js
class DeleteCookies (line 29) | class DeleteCookies extends ClientCommand {
method isTraceable (line 30) | static get isTraceable() {
method performAction (line 34) | performAction(callback) {
FILE: lib/api/client-commands/cookies/get.js
class GetCookie (line 37) | class GetCookie extends ClientCommand {
method performAction (line 38) | performAction(callback) {
method command (line 44) | command(name, callback) {
FILE: lib/api/client-commands/cookies/getAll.js
class GetCookies (line 36) | class GetCookies extends ClientCommand {
method performAction (line 37) | performAction(callback) {
FILE: lib/api/client-commands/cookies/set.js
class SetCookie (line 42) | class SetCookie extends ClientCommand {
method isTraceable (line 43) | static get isTraceable() {
method performAction (line 47) | performAction(callback) {
method command (line 53) | command(cookie, callback) {
FILE: lib/api/client-commands/debug.js
class Debug (line 51) | class Debug extends EventEmitter {
method avoidPrematureParentNodeResolution (line 52) | static get avoidPrematureParentNodeResolution() {
method command (line 56) | command(config, callback) {
FILE: lib/api/client-commands/deleteCookie.js
class DeleteCookie (line 22) | class DeleteCookie extends ClientCommand {
method returnsFullResultObject (line 23) | get returnsFullResultObject() {
method performAction (line 27) | performAction(callback) {
method isTraceable (line 31) | static get isTraceable() {
method command (line 35) | command(cookieName, callback) {
FILE: lib/api/client-commands/deleteCookies.js
class DeleteCookie (line 21) | class DeleteCookie extends ClientCommand {
method returnsFullResultObject (line 22) | get returnsFullResultObject() {
method isTraceable (line 26) | static get isTraceable() {
method performAction (line 30) | performAction(callback) {
FILE: lib/api/client-commands/document/executeAsyncScript.js
class ExecuteAsyncScript (line 53) | class ExecuteAsyncScript extends ClientCommand {
method namespacedAliases (line 54) | static get namespacedAliases() {
method isTraceable (line 58) | static get isTraceable() {
method performAction (line 62) | performAction(callback) {
method command (line 68) | command(script, args, callback) {
FILE: lib/api/client-commands/document/executeScript.js
class ExecuteScript (line 54) | class ExecuteScript extends ClientCommand {
method namespacedAliases (line 55) | static get namespacedAliases() {
method isTraceable (line 59) | static get isTraceable() {
method performAction (line 63) | performAction(callback) {
method command (line 69) | command(script, args, callback) {
FILE: lib/api/client-commands/document/injectScript.js
class InjectScript (line 28) | class InjectScript extends ClientCommand {
method isTraceable (line 29) | static get isTraceable() {
method performAction (line 33) | performAction(callback) {
method command (line 39) | command(scriptUrl, id, callback) {
FILE: lib/api/client-commands/document/source.js
class Source (line 27) | class Source extends ClientCommand {
method namespacedAliases (line 28) | static get namespacedAliases() {
method performAction (line 32) | performAction(callback) {
FILE: lib/api/client-commands/enablePerformanceMetrics.js
class EnablePerformanceMetrics (line 31) | class EnablePerformanceMetrics extends ClientCommand {
method performAction (line 33) | performAction(callback) {
method command (line 47) | command(enable, callback) {
FILE: lib/api/client-commands/end.js
class End (line 17) | class End extends EventEmitter {
method command (line 18) | command(forceEnd = !this.reuseBrowser, callback) {
method complete (line 45) | complete(callback, response) {
FILE: lib/api/client-commands/getCookie.js
class GetCookie (line 26) | class GetCookie extends ClientCommand {
method returnsFullResultObject (line 27) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 31) | get resolvesWithFullResultObject() {
method performAction (line 41) | performAction(actionCallback) {
method command (line 62) | command(name, callback) {
FILE: lib/api/client-commands/getCookies.js
class GetCookies (line 26) | class GetCookies extends ClientCommand {
method performAction (line 27) | performAction(callback) {
FILE: lib/api/client-commands/getLog.js
class GetLog (line 25) | class GetLog extends ClientCommand {
method returnsFullResultObject (line 26) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 30) | get resolvesWithFullResultObject() {
method performAction (line 34) | performAction(actionCallback) {
method command (line 38) | command(typeString = 'browser', callback) {
FILE: lib/api/client-commands/getLogTypes.js
class GetLogTypes (line 22) | class GetLogTypes extends ClientCommand {
method returnsFullResultObject (line 23) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 27) | get resolvesWithFullResultObject() {
method performAction (line 31) | performAction(actionCallback) {
FILE: lib/api/client-commands/getPerformanceMetrics.js
class GetPerformanceMetrics (line 31) | class GetPerformanceMetrics extends ClientCommand {
method performAction (line 33) | performAction(callback) {
method command (line 45) | command(callback) {
FILE: lib/api/client-commands/getTitle.js
class GetTitle (line 22) | class GetTitle extends ClientCommand {
method returnsFullResultObject (line 23) | get returnsFullResultObject() {
method performAction (line 27) | performAction(callback) {
FILE: lib/api/client-commands/getWindowPosition.js
class GetWindowPosition (line 32) | class GetWindowPosition extends ClientCommand {
method returnsFullResultObject (line 33) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 37) | get resolvesWithFullResultObject() {
method performAction (line 41) | performAction(callback) {
FILE: lib/api/client-commands/getWindowRect.js
class GetWindowRect (line 37) | class GetWindowRect extends ClientCommand {
method returnsFullResultObject (line 38) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 42) | get resolvesWithFullResultObject() {
method performAction (line 46) | performAction(callback) {
FILE: lib/api/client-commands/getWindowSize.js
class GetWindowSize (line 33) | class GetWindowSize extends ClientCommand {
method returnsFullResultObject (line 34) | get returnsFullResultObject() {
method resolvesWithFullResultObject (line 38) | get resolvesWithFullResultObject() {
method performAction (line 42) | performAction(callback) {
FILE: lib/api/client-commands/init.js
class Init (line 19) | class Init extends ClientCommand {
method performAction (line 21) | performAction(callback) {
method command (line 25) | command(url, callback) {
FILE: lib/api/client-commands/injectScript.js
class InjectScript (line 22) | class InjectScript extends ClientCommand {
method isTraceable (line 23) | static get isTraceable() {
method performAction (line 27) | performAction(callback) {
method command (line 32) | command(scriptUrl, id, callback) {
FILE: lib/api/client-commands/isLogAvailable.js
class IsLogAvailable (line 22) | class IsLogAvailable extends ClientCommand {
method performAction (line 23) | performAction(actionCallback) {
method command (line 39) | command(typeString = 'browser', callback) {
FILE: lib/api/client-commands/logs/captureBrowserConsoleLogs.js
class StartCapturingLogs (line 28) | class StartCapturingLogs extends ClientCommand {
method namespacedAliases (line 29) | static get namespacedAliases() {
method performAction (line 33) | performAction(callback) {
method command (line 52) | command(userCallback, callback) {
FILE: lib/api/client-commands/logs/captureBrowserExceptions.js
class CatchJsExceptions (line 32) | class CatchJsExceptions extends ClientCommand {
method namespacedAliases (line 33) | static get namespacedAliases() {
method performAction (line 37) | performAction(callback) {
method command (line 56) | command(userCallback, callback) {
FILE: lib/api/client-commands/logs/getSessionLog.js
class GetSessionLog (line 37) | class GetSessionLog extends ClientCommand {
method performAction (line 38) | performAction(callback) {
method command (line 42) | command(typeString = 'browser', callback) {
FILE: lib/api/client-commands/logs/getSessionLogTypes.js
class GetSessionLogTypes (line 28) | class GetSessionLogTypes extends ClientCommand {
method performAction (line 29) | performAction(callback) {
FILE: lib/api/client-commands/logs/isSessionLogAvailable.js
class IsSessionLogAvailable (line 33) | class IsSessionLogAvailable extends ClientCommand {
method performAction (line 34) | performAction(callback) {
method command (line 55) | command(typeString = 'browser', callback) {
FILE: lib/api/client-commands/maximizeWindow.js
class WindowMaximize (line 18) | class WindowMaximize extends ClientCommand {
method performAction (line 20) | performAction(callback) {
FILE: lib/api/client-commands/network/captureRequests.js
class CaptureNetworkCalls (line 30) | class CaptureNetworkCalls extends ClientCommand {
method namespacedAliases (line 32) | static get namespacedAliases() {
method performAction (line 36) | performAction(callback) {
method command (line 56) | command(userCallback, callback) {
FILE: lib/api/client-commands/network/mockResponse.js
class MockNetworkResponse (line 33) | class MockNetworkResponse extends ClientCommand {
method namespacedAliases (line 35) | static get namespacedAliases() {
method performAction (line 39) | performAction(callback) {
method command (line 61) | command(urlToIntercept, response, callback) {
FILE: lib/api/client-commands/network/setConditions.js
class SetNetworkConditions (line 28) | class SetNetworkConditions extends ClientCommand {
method namespacedAliases (line 30) | static get namespacedAliases() {
method performAction (line 34) | performAction(callback) {
method command (line 47) | command(spec, callback) {
FILE: lib/api/client-commands/pageSource.js
class PageSource (line 23) | class PageSource extends ClientCommand {
method returnsFullResultObject (line 24) | get returnsFullResultObject() {
method performAction (line 28) | performAction(callback) {
FILE: lib/api/client-commands/pause.js
class Pause (line 32) | class Pause extends EventEmitter {
method command (line 34) | command(ms, callback) {
FILE: lib/api/client-commands/perform.js
class Perform (line 60) | class Perform extends EventEmitter {
method alwaysAsync (line 61) | static get alwaysAsync() {
method avoidPrematureParentNodeResolution (line 65) | static get avoidPrematureParentNodeResolution() {
method command (line 69) | command(callback = function() {}) {
method runCallback (line 124) | runCallback(cb, args) {
FILE: lib/api/client-commands/registerBasicAuth.js
class RegisterBasicAuth (line 24) | class RegisterBasicAuth extends ClientCommand {
method isTraceable (line 25) | static get isTraceable() {
method performAction (line 29) | performAction(callback) {
method command (line 47) | command(username, password, callback) {
FILE: lib/api/client-commands/resizeWindow.js
class ResizeWindow (line 20) | class ResizeWindow extends ClientCommand {
method isTraceable (line 21) | static get isTraceable() {
method performAction (line 25) | performAction(callback) {
method command (line 37) | command(width, height, callback) {
FILE: lib/api/client-commands/saveScreenshot.js
class SaveScreenshot (line 20) | class SaveScreenshot extends ClientCommand {
method performAction (line 21) | performAction(callback) {
method command (line 44) | command(fileName, callback) {
FILE: lib/api/client-commands/saveSnapshot.js
class SaveSnapshot (line 19) | class SaveSnapshot extends ClientCommand {
method performAction (line 20) | performAction(callback) {
method createSnapshot (line 62) | async createSnapshot(baseUrl, pageSource) {
method command (line 80) | command(fileName, callback) {
FILE: lib/api/client-commands/setCookie.js
class SetCookie (line 30) | class SetCookie extends ClientCommand {
method isTraceable (line 31) | static get isTraceable() {
method performAction (line 35) | performAction(callback) {
method command (line 39) | command(cookie, callback) {
FILE: lib/api/client-commands/setDeviceDimensions.js
class SetDeviceDimensions (line 33) | class SetDeviceDimensions extends ClientCommand {
method isTraceable (line 34) | static get isTraceable() {
method performAction (line 38) | performAction(callback) {
method command (line 55) | command(metrics, callback) {
FILE: lib/api/client-commands/setGeolocation.js
class SetGeolocation (line 32) | class SetGeolocation extends ClientCommand {
method isTraceable (line 33) | static get isTraceable() {
method performAction (line 37) | performAction(callback) {
method command (line 73) | command(coordinates, callback) {
FILE: lib/api/client-commands/setWindowPosition.js
class SetWindowPosition (line 20) | class SetWindowPosition extends ClientCommand {
method performAction (line 21) | performAction(callback) {
method command (line 25) | command(offsetX, offsetY, callback) {
FILE: lib/api/client-commands/setWindowRect.js
class SetWindowRect (line 50) | class SetWindowRect extends ClientCommand {
method performAction (line 51) | performAction(callback) {
method command (line 55) | command(options, callback) {
FILE: lib/api/client-commands/setWindowSize.js
class SetWindowSize (line 20) | class SetWindowSize extends ClientCommand {
method performAction (line 21) | performAction(callback) {
method command (line 25) | command(width, height, callback) {
FILE: lib/api/client-commands/takeHeapSnapshot.js
class TakeHeapSnapshot (line 29) | class TakeHeapSnapshot extends ClientCommand {
method performAction (line 31) | performAction(callback) {
method command (line 45) | command(heapSnapshotLocation, callback) {
FILE: lib/api/client-commands/urlHash.js
class UrlHash (line 20) | class UrlHash extends ClientCommand {
method returnsFullResultObject (line 21) | get returnsFullResultObject() {
method performAction (line 25) | performAction(callback) {
method command (line 29) | command(hash, callback) {
FILE: lib/api/client-commands/useCss.js
class Command (line 19) | class Command extends LocateStrategy {
method constructor (line 20) | constructor() {
FILE: lib/api/client-commands/useXpath.js
class Command (line 19) | class Command extends LocateStrategy {
method constructor (line 20) | constructor() {
FILE: lib/api/client-commands/window/close.js
class CloseWindow (line 29) | class CloseWindow extends ClientCommand {
method performAction (line 30) | performAction(callback) {
FILE: lib/api/client-commands/window/fullscreen.js
class FullscreenWindow (line 27) | class FullscreenWindow extends ClientCommand {
method performAction (line 28) | performAction(callback) {
FILE: lib/api/client-commands/window/getAllHandles.js
class GetAllWindowHandles (line 29) | class GetAllWindowHandles extends ClientCommand {
method performAction (line 30) | performAction(callback) {
FILE: lib/api/client-commands/window/getHandle.js
class GetWindowHandle (line 31) | class GetWindowHandle extends ClientCommand {
method performAction (line 32) | performAction(callback) {
FILE: lib/api/client-commands/window/getPosition.js
class GetWindowPosition (line 28) | class GetWindowPosition extends ClientCommand {
method performAction (line 29) | performAction(callback) {
FILE: lib/api/client-commands/window/getRect.js
class GetWindowRect (line 39) | class GetWindowRect extends ClientCommand {
method performAction (line 40) | performAction(callback) {
FILE: lib/api/client-commands/window/getSize.js
class GetWindowSize (line 28) | class GetWindowSize extends ClientCommand {
method performAction (line 29) | performAction(callback) {
FILE: lib/api/client-commands/window/maximize.js
class MaximizeWindow (line 27) | class MaximizeWindow extends ClientCommand {
method performAction (line 28) | performAction(callback) {
FILE: lib/api/client-commands/window/minimize.js
class MinimizeWindow (line 27) | class MinimizeWindow extends ClientCommand {
method performAction (line 28) | performAction(callback) {
FILE: lib/api/client-commands/window/open.js
class OpenNewWindow (line 41) | class OpenNewWindow extends ClientCommand {
method isTraceable (line 42) | static get isTraceable() {
method namespacedAliases (line 46) | static get namespacedAliases() {
method performAction (line 50) | performAction(callback) {
method command (line 56) | command(type = 'tab', callback) {
FILE: lib/api/client-commands/window/setPosition.js
class SetWIndowPosition (line 30) | class SetWIndowPosition extends ClientCommand {
method performAction (line 31) | performAction(callback) {
method command (line 37) | command(x, y, callback) {
FILE: lib/api/client-commands/window/setRect.js
class SetWindowRect (line 47) | class SetWindowRect extends ClientCommand {
method performAction (line 48) | performAction(callback) {
method command (line 54) | command(options, callback) {
FILE: lib/api/client-commands/window/setSize.js
class SetWindowSize (line 28) | class SetWindowSize extends ClientCommand {
method namespacedAliases (line 29) | static get namespacedAliases() {
method performAction (line 33) | performAction(callback) {
method command (line 39) | command(width, height, callback) {
FILE: lib/api/client-commands/window/switchTo.js
class SwitchToWindow (line 75) | class SwitchToWindow extends ClientCommand {
method isTraceable (line 76) | static get isTraceable() {
method namespacedAliases (line 80) | static get namespacedAliases() {
method performAction (line 84) | performAction(callback) {
method command (line 90) | command(windowHandle, callback) {
FILE: lib/api/client-commands/within.js
method allowOverride (line 20) | static get allowOverride() {
FILE: lib/api/element-commands/_baseElementCommand.js
class BaseElementCommand (line 6) | class BaseElementCommand extends ElementCommand {
method w3c_deprecated (line 7) | get w3c_deprecated() {
method getErrorMessage (line 11) | static getErrorMessage(response = {}) {
method extraArgsCount (line 21) | get extraArgsCount() {
method retryOnFailure (line 25) | get retryOnFailure() {
method elementProtocolAction (line 29) | get elementProtocolAction() {
method isTraceable (line 33) | static get isTraceable() {
method setOptionsFromSelector (line 37) | setOptionsFromSelector() {
method findElementAction (line 43) | async findElementAction({cacheElementId = true} = {}) {
method setupActions (line 59) | setupActions() {
method elementNotFound (line 108) | elementNotFound(err) {
method shouldRetryElementCommand (line 112) | shouldRetryElementCommand(result) {
method protocolAction (line 120) | async protocolAction() {
method handleElementError (line 143) | handleElementError(err) {
FILE: lib/api/element-commands/_waitFor.js
class WaitForElement (line 11) | class WaitForElement extends ElementCommand {
method retryOnSuccess (line 12) | get retryOnSuccess() {
method rejectNodeOnAbortFailure (line 16) | static get rejectNodeOnAbortFailure() {
method isTraceable (line 20) | static get isTraceable() {
method isElementVisible (line 24) | static isElementVisible(result) {
method constructor (line 28) | constructor(opts) {
method validateArgsCount (line 34) | validateArgsCount() {
method setupActions (line 40) | setupActions() {
method setArguments (line 135) | setArguments() {
method pass (line 185) | pass(result, defaultMsg, timeMs) {
method fail (line 197) | fail(result, actual, expected, defaultMsg) {
method assert (line 210) | assert({result, passed, err}) {
method formatMessage (line 248) | formatMessage(defaultMsg, timeMs) {
method elementNotFound (line 252) | elementNotFound(result) {
FILE: lib/api/element-commands/_waitForDisplayed.js
class WaitForDisplayed (line 3) | class WaitForDisplayed extends WaitForElement {
method protocolAction (line 4) | protocolAction() {
method shouldRetryAction (line 8) | shouldRetryAction(elementVisible) {
method setupActions (line 12) | setupActions() {
method protocolActionHandler (line 54) | protocolActionHandler(result) {
method elementVisible (line 62) | elementVisible(response) {}
method elementNotVisible (line 63) | elementNotVisible(response) {}
FILE: lib/api/element-commands/check.js
class CheckElement (line 46) | class CheckElement extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method elementProtocolAction (line 51) | get elementProtocolAction() {
method isTraceable (line 55) | static get isTraceable() {
method protocolAction (line 59) | async protocolAction() {
FILE: lib/api/element-commands/clearValue.js
class ClearValue (line 43) | class ClearValue extends BaseElementCommand {
method extraArgsCount (line 44) | get extraArgsCount() {
method elementProtocolAction (line 48) | get elementProtocolAction() {
method isTraceable (line 52) | static get isTraceable() {
FILE: lib/api/element-commands/click.js
class ClickElement (line 47) | class ClickElement extends BaseElementCommand {
method extraArgsCount (line 48) | get extraArgsCount() {
method elementProtocolAction (line 52) | get elementProtocolAction() {
method isTraceable (line 56) | static get isTraceable() {
method protocolAction (line 60) | async protocolAction() {
FILE: lib/api/element-commands/clickAndHold.js
class ClickAndHold (line 48) | class ClickAndHold extends BaseElementCommand {
method extraArgsCount (line 49) | get extraArgsCount() {
method elementProtocolAction (line 53) | get elementProtocolAction() {
FILE: lib/api/element-commands/doubleClick.js
class doubleClick (line 47) | class doubleClick extends BaseElementCommand {
method extraArgsCount (line 48) | get extraArgsCount() {
method elementProtocolAction (line 52) | get elementProtocolAction() {
FILE: lib/api/element-commands/dragAndDrop.js
class DragElement (line 29) | class DragElement extends BaseElementCommand {
method extraArgsCount (line 30) | get extraArgsCount() {
method elementProtocolAction (line 34) | get elementProtocolAction() {
FILE: lib/api/element-commands/findElement.js
method elementFound (line 25) | async elementFound(response) {
method findElementAction (line 41) | findElementAction() {
FILE: lib/api/element-commands/findElements.js
method elementFound (line 26) | async elementFound(response) {
method findElementAction (line 44) | findElementAction() {
method complete (line 48) | async complete(err, response) {
FILE: lib/api/element-commands/getAccessibleName.js
class GetAccessibleName (line 52) | class GetAccessibleName extends BaseElementCommand {
method extraArgsCount (line 53) | get extraArgsCount() {
method elementProtocolAction (line 57) | get elementProtocolAction() {
FILE: lib/api/element-commands/getAriaRole.js
class GetAriaRole (line 52) | class GetAriaRole extends BaseElementCommand {
method extraArgsCount (line 53) | get extraArgsCount() {
method elementProtocolAction (line 57) | get elementProtocolAction() {
FILE: lib/api/element-commands/getAttribute.js
class GetAttribute (line 46) | class GetAttribute extends BaseElementCommand {
method namespacedAliases (line 47) | static get namespacedAliases() {
method extraArgsCount (line 51) | get extraArgsCount() {
method elementProtocolAction (line 55) | get elementProtocolAction() {
FILE: lib/api/element-commands/getCssProperty.js
class GetCssProperty (line 46) | class GetCssProperty extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method elementProtocolAction (line 51) | get elementProtocolAction() {
FILE: lib/api/element-commands/getElementProperty.js
class GetElementProperty (line 45) | class GetElementProperty extends BaseElementCommand {
method extraArgsCount (line 46) | get extraArgsCount() {
method elementProtocolAction (line 50) | get elementProtocolAction() {
FILE: lib/api/element-commands/getElementRect.js
class GetElementRect (line 49) | class GetElementRect extends BaseElementCommand {
method extraArgsCount (line 50) | get extraArgsCount() {
method elementProtocolAction (line 54) | get elementProtocolAction() {
FILE: lib/api/element-commands/getElementSize.js
class GetElementSize (line 49) | class GetElementSize extends BaseElementCommand {
method extraArgsCount (line 50) | get extraArgsCount() {
method elementProtocolAction (line 54) | get elementProtocolAction() {
FILE: lib/api/element-commands/getFirstElementChild.js
class GetFirstElementChild (line 25) | class GetFirstElementChild extends BaseElementCommand {
method extraArgsCount (line 27) | get extraArgsCount() {
method protocolAction (line 31) | async protocolAction() {
FILE: lib/api/element-commands/getLastElementChild.js
class GetLastElementChild (line 26) | class GetLastElementChild extends BaseElementCommand {
method extraArgsCount (line 28) | get extraArgsCount() {
method protocolAction (line 32) | async protocolAction() {
FILE: lib/api/element-commands/getLocation.js
class GetLocation (line 51) | class GetLocation extends BaseElementCommand {
method extraArgsCount (line 52) | get extraArgsCount() {
method elementProtocolAction (line 56) | get elementProtocolAction() {
FILE: lib/api/element-commands/getLocationInView.js
class GetLocationInView (line 28) | class GetLocationInView extends BaseElementCommand {
method w3c_deprecated (line 29) | get w3c_deprecated() {
method extraArgsCount (line 33) | get extraArgsCount() {
method elementProtocolAction (line 37) | get elementProtocolAction() {
FILE: lib/api/element-commands/getNextSibling.js
class GetNextSibling (line 25) | class GetNextSibling extends BaseElementCommand {
method extraArgsCount (line 27) | get extraArgsCount() {
method protocolAction (line 31) | async protocolAction() {
FILE: lib/api/element-commands/getPreviousSibling.js
class GetPreviousSibling (line 45) | class GetPreviousSibling extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method protocolAction (line 51) | async protocolAction() {
FILE: lib/api/element-commands/getShadowRoot.js
class ElementCommand (line 37) | class ElementCommand extends BaseElementCommand {
method protocolAction (line 38) | async protocolAction() {
FILE: lib/api/element-commands/getTagName.js
class GetTagName (line 45) | class GetTagName extends BaseElementCommand {
method extraArgsCount (line 46) | get extraArgsCount() {
method elementProtocolAction (line 50) | get elementProtocolAction() {
FILE: lib/api/element-commands/getText.js
class GetText (line 53) | class GetText extends BaseElementCommand {
method extraArgsCount (line 54) | get extraArgsCount() {
method elementProtocolAction (line 58) | get elementProtocolAction() {
FILE: lib/api/element-commands/getValue.js
class GetValue (line 44) | class GetValue extends BaseElementCommand {
method extraArgsCount (line 45) | get extraArgsCount() {
method protocolAction (line 49) | protocolAction() {
FILE: lib/api/element-commands/hasDescendants.js
class HasDescendants (line 23) | class HasDescendants extends BaseElementCommand {
method protocolAction (line 25) | async protocolAction() {
FILE: lib/api/element-commands/isEnabled.js
class IsEnabled (line 46) | class IsEnabled extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method elementProtocolAction (line 51) | get elementProtocolAction() {
FILE: lib/api/element-commands/isPresent.js
class isPresent (line 44) | class isPresent extends BaseElementCommand {
method elementLocateError (line 45) | elementLocateError(error) {
method protocolAction (line 58) | async protocolAction() {
FILE: lib/api/element-commands/isSelected.js
class IsSelected (line 46) | class IsSelected extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method elementProtocolAction (line 51) | get elementProtocolAction() {
FILE: lib/api/element-commands/isVisible.js
class IsVisible (line 47) | class IsVisible extends BaseElementCommand {
method extraArgsCount (line 48) | get extraArgsCount() {
method protocolAction (line 52) | protocolAction() {
FILE: lib/api/element-commands/moveToElement.js
class MoveToElement (line 24) | class MoveToElement extends BaseElementCommand {
method extraArgsCount (line 25) | get extraArgsCount() {
method elementProtocolAction (line 29) | get elementProtocolAction() {
FILE: lib/api/element-commands/rightClick.js
class RightClick (line 48) | class RightClick extends BaseElementCommand {
method extraArgsCount (line 49) | get extraArgsCount() {
method elementProtocolAction (line 53) | get elementProtocolAction() {
FILE: lib/api/element-commands/sendKeys.js
class SendKeys (line 32) | class SendKeys extends BaseElementCommand {
method isTraceable (line 33) | static get isTraceable() {
method extraArgsCount (line 37) | get extraArgsCount() {
method elementProtocolAction (line 41) | get elementProtocolAction() {
FILE: lib/api/element-commands/setAttribute.js
class SetAttribute (line 44) | class SetAttribute extends BaseElementCommand {
method extraArgsCount (line 45) | get extraArgsCount() {
method elementProtocolAction (line 49) | get elementProtocolAction() {
FILE: lib/api/element-commands/setPassword.js
class SetPassword (line 31) | class SetPassword extends BaseElementCommand {
method namespacedAliases (line 32) | static get namespacedAliases() {
method RedactParams (line 36) | static get RedactParams(){
method extraArgsCount (line 40) | get extraArgsCount() {
method elementProtocolAction (line 44) | get elementProtocolAction() {
FILE: lib/api/element-commands/setValue.js
class SetValue (line 32) | class SetValue extends BaseElementCommand {
method isTraceable (line 34) | static get isTraceable() {
method extraArgsCount (line 38) | get extraArgsCount() {
method elementProtocolAction (line 42) | get elementProtocolAction() {
FILE: lib/api/element-commands/submitForm.js
class SubmitForm (line 21) | class SubmitForm extends BaseElementCommand {
method extraArgsCount (line 22) | get extraArgsCount() {
method elementProtocolAction (line 26) | get elementProtocolAction() {
FILE: lib/api/element-commands/takeElementScreenshot.js
class TakeElementScreenshot (line 50) | class TakeElementScreenshot extends BaseElementCommand {
method elementProtocolAction (line 51) | get elementProtocolAction() {
FILE: lib/api/element-commands/uncheck.js
class UncheckElement (line 46) | class UncheckElement extends BaseElementCommand {
method extraArgsCount (line 47) | get extraArgsCount() {
method elementProtocolAction (line 51) | get elementProtocolAction() {
method isTraceable (line 55) | static get isTraceable() {
method protocolAction (line 59) | async protocolAction() {
FILE: lib/api/element-commands/updateValue.js
class SetValue (line 32) | class SetValue extends BaseElementCommand {
method extraArgsCount (line 33) | get extraArgsCount() {
method elementProtocolAction (line 37) | get elementProtocolAction() {
method protocolAction (line 41) | protocolAction() {
FILE: lib/api/element-commands/uploadFile.js
class UploadFile (line 24) | class UploadFile extends BaseElementCommand {
method extraArgsCount (line 25) | get extraArgsCount() {
method elementProtocolAction (line 29) | get elementProtocolAction() {
FILE: lib/api/element-commands/waitForElementNotPresent.js
class WaitForElementNotPresent (line 84) | class WaitForElementNotPresent extends WaitForElement {
method retryOnSuccess (line 85) | get retryOnSuccess() {
method constructor (line 89) | constructor(opts) {
method elementFound (line 101) | elementFound(result) {
method elementNotFound (line 108) | elementNotFound(result) {
FILE: lib/api/element-commands/waitForElementNotVisible.js
class WaitForElementNotVisible (line 84) | class WaitForElementNotVisible extends WaitForDisplayed {
method constructor (line 85) | constructor(opts) {
method shouldRetryAction (line 91) | shouldRetryAction(elementVisible) {
method elementVisible (line 95) | elementVisible(response) {
method elementNotVisible (line 101) | elementNotVisible(response) {
FILE: lib/api/element-commands/waitForElementPresent.js
class WaitForElementPresent (line 83) | class WaitForElementPresent extends WaitForElement {
method retryOnSuccess (line 84) | get retryOnSuccess() {
method elementFound (line 88) | elementFound(result) {
FILE: lib/api/element-commands/waitForElementVisible.js
class WaitForElementVisible (line 85) | class WaitForElementVisible extends WaitForDisplayed {
method constructor (line 86) | constructor(opts) {
method shouldRetryAction (line 92) | shouldRetryAction(elementVisible) {
method elementVisible (line 96) | elementVisible(response) {
method elementNotVisible (line 102) | elementNotVisible(response) {
FILE: lib/api/expect/_baseExpect.js
class ValueExpectAssertion (line 7) | class ValueExpectAssertion extends BaseAssertion {
method getMessage (line 8) | getMessage(negate) {
method init (line 18) | init() {
method executeCommand (line 26) | executeCommand() {
method onResultSuccess (line 32) | onResultSuccess() {
method onResultFailed (line 40) | onResultFailed() {
method formatMessage (line 44) | formatMessage() {
class ExpectInstance (line 63) | class ExpectInstance extends EventEmitter {
method flag (line 65) | flag(...args) {
method client (line 69) | get client() {
method commandFileName (line 73) | get commandFileName() {
method commandArgs (line 77) | get commandArgs() {
method transport (line 81) | get transport() {
method transportActions (line 85) | get transportActions() {
method elementLocator (line 89) | get elementLocator() {
method instance (line 93) | get instance() {
method stackTrace (line 97) | get stackTrace() {
method stackTrace (line 101) | set stackTrace(val) {
method toString (line 105) | toString() {
method constructor (line 109) | constructor({commandName, nightwatchInstance, commandArgs}) {
method run (line 132) | run(...args) {
method createLocalPromise (line 139) | createLocalPromise() {
method createInstance (line 146) | createInstance() {
method createRetryPromise (line 168) | createRetryPromise() {
method retryCommand (line 175) | retryCommand() {
method command (line 185) | command(...args) {
method handleCommandPromise (line 192) | handleCommandPromise(promise) {
method checkFlags (line 207) | checkFlags() {
method initAssertion (line 219) | initAssertion({AssertModule = ValueExpectAssertion, message = null, ar...
FILE: lib/api/expect/assertions/_baseAssertion.js
class BaseAssertion (line 31) | class BaseAssertion {
method AssertionType (line 32) | static get AssertionType () {
method ASSERT_FLAGS (line 39) | static get ASSERT_FLAGS() {
method transport (line 57) | get transport() {
method reporter (line 61) | get reporter() {
method transportActions (line 65) | get transportActions() {
method assertion (line 69) | get assertion() {
method selector (line 73) | get selector() {
method executeCommand (line 81) | executeCommand() {}
method onResultSuccess (line 86) | onResultSuccess() {}
method onResultFailed (line 91) | onResultFailed() {}
method flag (line 93) | flag(key, value) {
method getFlags (line 103) | getFlags() {
method setFlags (line 107) | setFlags() {
method constructor (line 140) | constructor({nightwatchInstance, chaiExpect, expectCommandName, messag...
method init (line 147) | init() {
method start (line 171) | start() {
method getResultValue (line 175) | getResultValue(result) {
method getResultStatus (line 183) | getResultStatus(result) {
method getResultError (line 191) | getResultError(result) {
method onPromiseResolved (line 199) | onPromiseResolved() {
method onExecuteCommandResult (line 211) | onExecuteCommandResult(result) {
method elementNotFoundError (line 226) | elementNotFoundError(response) {
method onPromiseRejected (line 230) | onPromiseRejected(response) {
method getActual (line 266) | getActual(actual) {
method processFlags (line 274) | processFlags() {
method hasFlag (line 283) | hasFlag(type) {
method done (line 287) | done() {
method runAssertion (line 292) | runAssertion() {
method getResult (line 342) | getResult(value, fn) {
method shouldRetry (line 349) | shouldRetry() {
method getElapsedTime (line 359) | getElapsedTime() {
method scheduleRetry (line 365) | scheduleRetry() {
method formatMessage (line 371) | formatMessage() {
method '@containsFlag' (line 383) | '@containsFlag'(value) {
method '@startsWithFlag' (line 399) | '@startsWithFlag'(value) {
method '@endsWithFlag' (line 418) | '@endsWithFlag'(value) {
method '@equalFlag' (line 437) | '@equalFlag'(value) {
method '@matchesFlag' (line 469) | '@matchesFlag'(re) {
method conditionFlag (line 483) | conditionFlag(value, conditionFn, arrverb) {
method setNegate (line 504) | setNegate() {
method setDeepEqualFlag (line 510) | setDeepEqualFlag() {
method setWaitForFlag (line 516) | setWaitForFlag(waitForConditionTimeout) {
method '@beforeFlag' (line 525) | '@beforeFlag'(value) {}
method '@afterFlag' (line 527) | '@afterFlag'(value) {}
method '@haveFlag' (line 529) | '@haveFlag'(value) {}
method '@waitForFlag' (line 531) | '@waitForFlag'(value) {
method '@andFlag' (line 537) | '@andFlag'() {
method '@thatFlag' (line 549) | '@thatFlag'() {
method '@whichFlag' (line 561) | '@whichFlag'() {
method '@beFlag' (line 573) | '@beFlag'() {}
method addTimeMessagePart (line 575) | addTimeMessagePart() {
method addExpectedMessage (line 586) | addExpectedMessage() {
method addExpectedInMessagePart (line 599) | addExpectedInMessagePart() {
method hasCondition (line 607) | hasCondition() {
method retryCommand (line 617) | retryCommand() {
FILE: lib/api/expect/assertions/element/_element-assertion.js
class ExpectElement (line 4) | class ExpectElement extends BaseAssertion {
method onResultSuccess (line 8) | onResultSuccess() {}
method onResultFailed (line 13) | onResultFailed() {}
method onPromiseResolved (line 15) | onPromiseResolved(value) {
method formatMessage (line 27) | formatMessage() {
method executeProtocolAction (line 49) | executeProtocolAction(protocolAction, args = []) {
method retryCommand (line 67) | retryCommand() {
method shouldRetryLocateElement (line 80) | shouldRetryLocateElement() {
method isRetryableElementError (line 84) | isRetryableElementError() {
method isComponent (line 88) | isComponent() {
FILE: lib/api/expect/assertions/element/active.js
class ActiveAssertion (line 19) | class ActiveAssertion extends BaseAssertion {
method assertionType (line 20) | static get assertionType() {
method init (line 24) | init() {
method executeCommand (line 32) | executeCommand() {
method compareElementIds (line 36) | compareElementIds() {
method onResultSuccess (line 40) | onResultSuccess() {
method onResultFailed (line 50) | onResultFailed() {
FILE: lib/api/expect/assertions/element/attribute.js
class AttributeAssertion (line 31) | class AttributeAssertion extends BaseAssertion {
method assertionType (line 32) | static get assertionType() {
method init (line 36) | init(attribute, msg) {
method executeCommand (line 47) | executeCommand() {
method onExecuteCommandResult (line 52) | onExecuteCommandResult(result) {
method onResultSuccess (line 73) | onResultSuccess() {
method attributeNotFound (line 87) | attributeNotFound() {
method onResultFailed (line 114) | onResultFailed() {
FILE: lib/api/expect/assertions/element/css.js
class CssAssertion (line 25) | class CssAssertion extends BaseAssertion {
method assertionType (line 26) | static get assertionType() {
method init (line 30) | init(property, msg) {
method executeCommand (line 40) | executeCommand() {
method '@haveFlag' (line 44) | '@haveFlag'() {
method onResultSuccess (line 50) | onResultSuccess() {
method onResultFailed (line 58) | onResultFailed() {
FILE: lib/api/expect/assertions/element/enabled.js
class EnabledAssertion (line 19) | class EnabledAssertion extends BaseAssertion {
method assertionType (line 20) | static get assertionType() {
method init (line 24) | init() {
method executeCommand (line 32) | executeCommand() {
method onResultSuccess (line 36) | onResultSuccess() {
method onResultFailed (line 48) | onResultFailed() {
FILE: lib/api/expect/assertions/element/present.js
class PresentAssertion (line 19) | class PresentAssertion extends BaseAssertion {
method assertionType (line 20) | static get assertionType() {
method isElementNotFoundError (line 24) | isElementNotFoundError() {
method init (line 28) | init() {
method executeCommand (line 36) | executeCommand() {
method onResultSuccess (line 40) | onResultSuccess() {
method onResultFailed (line 55) | onResultFailed() {
method retryCommand (line 68) | retryCommand() {
FILE: lib/api/expect/assertions/element/property.js
class PropertyAssertion (line 22) | class PropertyAssertion extends BaseAssertion {
method aliases (line 23) | static get aliases() {
method assertionType (line 27) | static get assertionType() {
method init (line 31) | init(property, msg) {
method executeCommand (line 42) | executeCommand() {
method hasProperty (line 53) | hasProperty() {
method onExecuteCommandResult (line 61) | onExecuteCommandResult(result) {
method onResultSuccess (line 82) | onResultSuccess() {
method propertyNotFound (line 96) | propertyNotFound() {
method onResultFailed (line 116) | onResultFailed() {
FILE: lib/api/expect/assertions/element/selected.js
class SelectedAssertion (line 18) | class SelectedAssertion extends BaseAssertion {
method assertionType (line 19) | static get assertionType() {
method init (line 23) | init() {
method executeCommand (line 31) | executeCommand() {
method onResultSuccess (line 35) | onResultSuccess() {
method onResultFailed (line 47) | onResultFailed() {
FILE: lib/api/expect/assertions/element/text.js
class TextAssertion (line 21) | class TextAssertion extends BaseAssertion {
method assertionType (line 22) | static get assertionType() {
method init (line 26) | init() {
method executeCommand (line 34) | executeCommand() {
method onResultSuccess (line 38) | onResultSuccess() {
method onResultFailed (line 46) | onResultFailed() {
FILE: lib/api/expect/assertions/element/type.js
class TypeAssertion (line 21) | class TypeAssertion extends BaseAssertion {
method assertionName (line 22) | static get assertionName() {
method assertionType (line 26) | static get assertionType() {
method init (line 30) | init(type, msg) {
method executeCommand (line 42) | executeCommand() {
method onResultSuccess (line 46) | onResultSuccess() {
method onResultFailed (line 66) | onResultFailed() {
FILE: lib/api/expect/assertions/element/value.js
class ValueAssertion (line 19) | class ValueAssertion extends BaseAssertion {
method assertionType (line 20) | static get assertionType() {
method init (line 24) | init() {
method executeCommand (line 33) | executeCommand() {
method onExecuteCommandResult (line 37) | onExecuteCommandResult(result) {
method onResultSuccess (line 58) | onResultSuccess() {
method valueNotFound (line 66) | valueNotFound() {
method onResultFailed (line 86) | onResultFailed() {
FILE: lib/api/expect/assertions/element/visible.js
class VisibleAssertion (line 18) | class VisibleAssertion extends BaseAssertion {
method assertionType (line 19) | static get assertionType() {
method init (line 23) | init() {
method executeCommand (line 31) | executeCommand() {
method onResultSuccess (line 35) | onResultSuccess() {
method onResultFailed (line 43) | onResultFailed() {
method getActual (line 49) | getActual() {
FILE: lib/api/expect/assertions/elements/count.js
class CountAssertion (line 17) | class CountAssertion extends BaseAssertion {
method assertionName (line 18) | static get assertionName() {
method assertionType (line 22) | static get assertionType() {
method init (line 26) | init() {
method executeCommand (line 35) | executeCommand() {
method getActual (line 46) | getActual(actual) {
method onResultSuccess (line 54) | onResultSuccess() {
method onResultFailed (line 62) | onResultFailed() {
FILE: lib/api/expect/component.js
class ExpectComponent (line 3) | class ExpectComponent extends ExpectElement {
method constructor (line 4) | constructor(...args) {
FILE: lib/api/expect/cookie.js
class ExpectCookie (line 20) | class ExpectCookie extends BaseExpect {
method needsFlags (line 21) | get needsFlags() {
method hasAssertions (line 25) | get hasAssertions() {
method getMessage (line 29) | getMessage(negate) {
method command (line 43) | command(...args) {
method handleCommandPromise (line 47) | handleCommandPromise(promise) {
class NotFoundError (line 74) | class NotFoundError extends Error {
method constructor (line 75) | constructor(props) {
FILE: lib/api/expect/element.js
class ExpectElement (line 5) | class ExpectElement extends BaseExpect {
method needsFlags (line 6) | get needsFlags() {
method hasAssertions (line 21) | get hasAssertions() {
method promiseRejectedMsg (line 25) | get promiseRejectedMsg() {
method assertionsPath (line 33) | get assertionsPath() {
method command (line 41) | command(...args) {
method getComponentProperty (line 47) | getComponentProperty(property) {
method retryCommand (line 58) | retryCommand() {
method createElement (line 63) | createElement(selector, using = this.client.locateStrategy) {
method locateElement (line 77) | locateElement() {
FILE: lib/api/expect/elements.js
class ExpectElements (line 4) | class ExpectElements extends BaseExpect {
method needsFlags (line 5) | get needsFlags() {
method hasAssertions (line 9) | get hasAssertions() {
method promiseRejectedMsg (line 13) | get promiseRejectedMsg() {
method assertionsPath (line 21) | get assertionsPath() {
method constructor (line 25) | constructor(opts) {
method command (line 35) | async command(...args) {
method locateElements (line 53) | locateElements() {
method retryCommand (line 76) | retryCommand() {
method createElement (line 81) | createElement(selector, using = this.client.locateStrategy) {
FILE: lib/api/expect/title.js
class ExpectTitle (line 17) | class ExpectTitle extends BaseExpect {
method needsFlags (line 18) | get needsFlags() {
method assertionType (line 28) | get assertionType() {
method hasAssertions (line 32) | get hasAssertions() {
method getMessage (line 36) | getMessage(negate) {
method command (line 40) | command() {
FILE: lib/api/expect/url.js
class ExpectUrl (line 17) | class ExpectUrl extends BaseExpect {
method needsFlags (line 18) | get needsFlags() {
method assertionType (line 28) | get assertionType() {
method hasAssertions (line 32) | get hasAssertions() {
method getMessage (line 36) | getMessage(negate) {
method command (line 40) | command() {
FILE: lib/api/index.js
constant DEFAULT_PLUGINS (line 15) | const DEFAULT_PLUGINS = ['nightwatch-axe-verbose'];
class ApiLoader (line 17) | class ApiLoader {
method isElementCommand (line 18) | static isElementCommand(commandName) {
method CommandFiles (line 22) | static get CommandFiles() {
method adaptCustomPath (line 70) | static adaptCustomPath(customPath) {
method getElementsCommandsStrict (line 76) | static getElementsCommandsStrict() {
method init (line 80) | static init(nightwatchInstance) {
method constructor (line 112) | constructor(nightwatchInstance) {
method api (line 116) | get api() {
method reporter (line 120) | get reporter() {
method settings (line 124) | get settings() {
method commandQueue (line 128) | get commandQueue() {
method makeAssertProxy (line 132) | static makeAssertProxy(api) {
method initPluginTransforms (line 168) | initPluginTransforms() {
method loadPlugins (line 174) | loadPlugins(parent = null) {
method defineWithinContext (line 208) | async defineWithinContext(parent) {
method loadPageObjects (line 219) | async loadPageObjects(parent = null) {
method loadCustomAssertions (line 235) | loadCustomAssertions(parent = null) {
method loadCustomCommands (line 248) | loadCustomCommands(parent = null) {
method loadApiCommandsSync (line 261) | loadApiCommandsSync(parent = null, {loadAssertions = true, loadClientC...
method addCommandDefinitionSync (line 316) | addCommandDefinitionSync({
method addCommandDefinitionAsync (line 349) | async addCommandDefinitionAsync({
method __loadCustomObjects (line 374) | __loadCustomObjects({parent = null, Loader = CommandLoader, namespaces...
method __loadCommandsSync (line 428) | __loadCommandsSync({
method __loadCommands (line 486) | __loadCommands({
method __normalizeTransforms (line 543) | __normalizeTransforms(transforms) {
method __loadPluginTransforms (line 554) | __loadPluginTransforms(nextTransforms) {
FILE: lib/api/protocol/_base-action.js
method ScreenOrientation (line 7) | static get ScreenOrientation() {
method MouseButton (line 11) | static get MouseButton() {
method validateElementId (line 19) | static validateElementId(id, apiMethod) {
method elementCommandToActionMap (line 27) | static get elementCommandToActionMap() {
method reportProtocolErrors (line 56) | reportProtocolErrors(result) {
method elementLocator (line 60) | get elementLocator() {
method transport (line 64) | get transport() {
method requiresSeleniumWebdriver (line 68) | get requiresSeleniumWebdriver() {
method settings (line 72) | get settings() {
method client (line 80) | get client() {
method api (line 84) | get api() {
method constructor (line 88) | constructor(nightwatchInstance) {
method command (line 96) | async command() {}
method findElements (line 109) | findElements({element, parentElement, id, using, value, commandName, cal...
method locate (line 140) | async locate({id, element, parentElement, commandName}) {
method mouseButtonHandler (line 171) | mouseButtonHandler(handler, button, callback) {
FILE: lib/api/protocol/acceptAlert.js
method isTraceable (line 14) | static get isTraceable() {
method command (line 18) | command(callback) {
FILE: lib/api/protocol/appium/getContext.js
method command (line 33) | command(callback) {
FILE: lib/api/protocol/appium/getContexts.js
method command (line 33) | command(callback) {
FILE: lib/api/protocol/appium/getCurrentActivity.js
method command (line 30) | command(callback) {
FILE: lib/api/protocol/appium/getCurrentPackage.js
method command (line 30) | command(callback) {
FILE: lib/api/protocol/appium/getGeolocation.js
method command (line 29) | command(callback) {
FILE: lib/api/protocol/appium/getOrientation.js
method command (line 29) | command(callback) {
FILE: lib/api/protocol/appium/hideKeyboard.js
method isTraceable (line 25) | static get isTraceable() {
method command (line 29) | command(callback) {
FILE: lib/api/protocol/appium/isKeyboardShown.js
method command (line 29) | command(callback) {
FILE: lib/api/protocol/appium/longPressKeyCode.js
method isTraceable (line 31) | static get isTraceable() {
method command (line 35) | command(keycode, ...args) {
FILE: lib/api/protocol/appium/pressKeyCode.js
method isTraceable (line 31) | static get isTraceable() {
method command (line 35) | command(keycode, ...args) {
FILE: lib/api/protocol/appium/resetApp.js
method isTraceable (line 22) | static get isTraceable() {
method command (line 26) | command(callback) {
FILE: lib/api/protocol/appium/setContext.js
method isTraceable (line 41) | static get isTraceable() {
method command (line 45) | command(context, callback) {
FILE: lib/api/protocol/appium/setGeolocation.js
method isTraceable (line 26) | static get isTraceable() {
method command (line 30) | command(coordinates = {}, callback) {
FILE: lib/api/protocol/appium/setOrientation.js
method isTraceable (line 26) | static get isTraceable() {
method command (line 30) | command(orientation, callback) {
FILE: lib/api/protocol/appium/startActivity.js
method isTraceable (line 37) | static get isTraceable() {
method command (line 41) | command(opts = {}, callback) {
FILE: lib/api/protocol/back.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(callback) {
FILE: lib/api/protocol/closeWindow.js
method command (line 14) | command(callback) {
FILE: lib/api/protocol/contexts.js
method command (line 15) | command(callback) {
FILE: lib/api/protocol/cookie.js
method isTraceable (line 18) | static get isTraceable() {
method command (line 22) | command(method, callbackOrCookie) {
FILE: lib/api/protocol/currentContext.js
method command (line 12) | command(callback) {
FILE: lib/api/protocol/dismissAlert.js
method isTraceable (line 14) | static get isTraceable() {
method command (line 18) | command(callback) {
FILE: lib/api/protocol/element.js
method reportProtocolErrors (line 52) | reportProtocolErrors(result) {
method command (line 56) | command(using, value, callback) {
FILE: lib/api/protocol/elementActive.js
method command (line 23) | command(callback) {
FILE: lib/api/protocol/elementIdAttribute.js
method isTraceable (line 14) | static get isTraceable() {
method command (line 18) | command(webElementId, attributeName, callback) {
FILE: lib/api/protocol/elementIdClear.js
method isTraceable (line 13) | static get isTraceable() {
method command (line 17) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdClick.js
method isTraceable (line 13) | static get isTraceable() {
method command (line 17) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdCssProperty.js
method isTraceable (line 16) | static get isTraceable() {
method command (line 20) | command(webElementId, cssPropertyName, callback) {
FILE: lib/api/protocol/elementIdDisplayed.js
method command (line 13) | async command(webElementId, callback) {
FILE: lib/api/protocol/elementIdDoubleClick.js
method isTraceable (line 13) | static get isTraceable() {
method command (line 17) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdElement.js
method command (line 47) | command(webElementId, using, value, callback = function (r) {return r}) {
FILE: lib/api/protocol/elementIdElements.js
method command (line 46) | command(webElementId, using, value, callback = function (r) {return r}) {
FILE: lib/api/protocol/elementIdEnabled.js
method command (line 13) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdEquals.js
method w3c_deprecated (line 27) | get w3c_deprecated() {
method deprecationNotice (line 31) | get deprecationNotice() {
method command (line 35) | command(webElementId, otherId, callback) {
FILE: lib/api/protocol/elementIdLocation.js
method w3c_deprecated (line 14) | get w3c_deprecated() {
method deprecationNotice (line 18) | get deprecationNotice() {
method command (line 22) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdLocationInView.js
method w3c_deprecated (line 13) | get w3c_deprecated() {
method command (line 17) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdName.js
method command (line 13) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdProperty.js
method command (line 14) | command(webElementId, DOMPropertyName, callback) {
FILE: lib/api/protocol/elementIdSelected.js
method command (line 13) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdSize.js
method w3c_deprecated (line 12) | get w3c_deprecated() {
method deprecationNotice (line 16) | get deprecationNotice() {
method command (line 20) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdText.js
method command (line 13) | command(webElementId, callback) {
FILE: lib/api/protocol/elementIdValue.js
method w3c_deprecated (line 14) | get w3c_deprecated() {
method command (line 18) | command(webElementId, value, callback) {
FILE: lib/api/protocol/elements.js
method command (line 53) | command(using, value, callback) {
FILE: lib/api/protocol/forward.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(callback) {
FILE: lib/api/protocol/frame.js
method avoidPrematureParentNodeResolution (line 44) | static get avoidPrematureParentNodeResolution() {
method command (line 48) | async command(frameId, callback) {
FILE: lib/api/protocol/frameParent.js
method command (line 20) | command(callback) {
FILE: lib/api/protocol/fullscreenWindow.js
method isTraceable (line 26) | static get isTraceable() {
method command (line 30) | command(callback) {
FILE: lib/api/protocol/getAlertText.js
method command (line 13) | command(callback) {
FILE: lib/api/protocol/getCurrentUrl.js
method command (line 32) | command(callback = function(r) {return r}) {
FILE: lib/api/protocol/getOrientation.js
method command (line 12) | command(callback) {
FILE: lib/api/protocol/keys.js
method isTraceable (line 27) | static get isTraceable() {
method command (line 31) | command(keysToSend, callback) {
method w3c_deprecated (line 39) | get w3c_deprecated() {
method deprecationNotice (line 43) | get deprecationNotice() {
FILE: lib/api/protocol/minimizeWindow.js
method isTraceable (line 26) | static get isTraceable() {
method command (line 30) | command(callback) {
FILE: lib/api/protocol/mouseButtonClick.js
method w3c_deprecated (line 16) | get w3c_deprecated() {
method deprecationNotice (line 20) | get deprecationNotice() {
method isTraceable (line 24) | static get isTraceable() {
method command (line 28) | command(button, callback) {
FILE: lib/api/protocol/mouseButtonDown.js
method isTraceable (line 15) | static get isTraceable() {
method command (line 19) | command(button, callback) {
FILE: lib/api/protocol/mouseButtonUp.js
method isTraceable (line 15) | static get isTraceable() {
method command (line 19) | command(button, callback) {
FILE: lib/api/protocol/moveTo.js
method isTraceable (line 26) | static get isTraceable() {
method command (line 30) | command(...args) {
FILE: lib/api/protocol/navigateTo.js
method isTraceable (line 35) | static get isTraceable() {
method command (line 39) | command(url, callback = function(r) {return r}) {
FILE: lib/api/protocol/openNewWindow.js
method command (line 35) | command(type = 'tab', callback) {
FILE: lib/api/protocol/quit.js
method command (line 23) | async command(callback = function(r) {return r}) {
FILE: lib/api/protocol/refresh.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(callback) {
FILE: lib/api/protocol/releaseMouseButton.js
method isTraceable (line 10) | static get isTraceable() {
method command (line 14) | command(callback) {
FILE: lib/api/protocol/screenshot.js
method command (line 13) | command(log_screenshot_data = false, callback = function (r) {return r}) {
FILE: lib/api/protocol/session.js
method SessionActions (line 32) | static get SessionActions() {
method command (line 40) | command(action = Session.SessionActions.GET, sessionId, callback) {
FILE: lib/api/protocol/sessionLog.js
method command (line 23) | command(typeString, callback) {
FILE: lib/api/protocol/sessionLogTypes.js
method command (line 18) | command(callback) {
FILE: lib/api/protocol/sessions.js
method command (line 21) | command(callback) {
FILE: lib/api/protocol/setAlertText.js
method isTraceable (line 13) | static get isTraceable() {
method command (line 17) | command(value, callback) {
FILE: lib/api/protocol/setContext.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(context, callback) {
FILE: lib/api/protocol/setOrientation.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(orientation, callback) {
FILE: lib/api/protocol/source.js
method command (line 12) | command(callback) {
FILE: lib/api/protocol/status.js
method command (line 13) | command(callback) {
FILE: lib/api/protocol/submit.js
method isTraceable (line 12) | static get isTraceable() {
method command (line 16) | command(webElementId, callback) {
FILE: lib/api/protocol/switchToWindow.js
method namespacedAliases (line 31) | static get namespacedAliases() {
method isTraceable (line 35) | static get isTraceable() {
method command (line 39) | command(handleOrName, callback) {
FILE: lib/api/protocol/timeouts.js
method TimeoutTypes (line 32) | static get TimeoutTypes() {
method command (line 40) | command(type, ms, callback) {
FILE: lib/api/protocol/timeoutsAsyncScript.js
method command (line 21) | command(ms, callback) {
FILE: lib/api/protocol/timeoutsImplicitWait.js
method command (line 21) | command(ms, callback) {
FILE: lib/api/protocol/title.js
method command (line 18) | command(callback) {
FILE: lib/api/protocol/url.js
method isTraceable (line 34) | static get isTraceable() {
method command (line 38) | command(url, callback = function(r) {return r}) {
FILE: lib/api/protocol/waitUntil.js
method requiresSeleniumWebdriver (line 41) | get requiresSeleniumWebdriver() {
method isParamTypeValid (line 45) | static isParamTypeValid(param, expectedType) {
method hasMessage (line 56) | static hasMessage(msg) {
method isTraceable (line 60) | static get isTraceable() {
method avoidPrematureParentNodeResolution (line 64) | static get avoidPrematureParentNodeResolution() {
method rejectNodeOnAbortFailure (line 68) | static get rejectNodeOnAbortFailure() {
method command (line 73) | async command(conditionFn, ...args) {
FILE: lib/api/protocol/windowHandle.js
method isTraceable (line 19) | static get isTraceable() {
method command (line 23) | command(callback) {
FILE: lib/api/protocol/windowHandles.js
method isTraceable (line 20) | static get isTraceable() {
method command (line 24) | command(callback) {
FILE: lib/api/protocol/windowMaximize.js
method command (line 34) | command(handleOrName = 'current', callback) {
FILE: lib/api/protocol/windowPosition.js
method command (line 32) | command(windowHandle, offsetX, offsetY, callback) {
FILE: lib/api/protocol/windowRect.js
method command (line 47) | command(options, callback = function(r) {return r}) {
FILE: lib/api/protocol/windowSize.js
method command (line 31) | command(windowHandle, width, height, callback) {
FILE: lib/api/web-element/assert/element-assertions.js
class ScopedElementAssertions (line 3) | class ScopedElementAssertions {
method constructor (line 4) | constructor(scopedElement, {negated, nightwatchInstance}) {
method assert (line 10) | assert(callback) {
method executeScript (line 39) | async executeScript(scriptFn, args) {
method get (line 52) | get() {
method value (line 62) | value(message) {
method value (line 69) | value(message) {
method value (line 76) | value(message) {
method value (line 83) | value(message) {
method value (line 90) | value(message) {
method value (line 102) | async value(name, message = `Testing if the element has "${name}" class....
method value (line 114) | async value(name, message = `Testing if the element has "${name}" attrib...
method value (line 126) | async value(scriptFn = function(el) {return el}, args = [], message = '') {
FILE: lib/api/web-element/assert/elements-assertions.js
class ElementsAssertions (line 1) | class ElementsAssertions {
method constructor (line 2) | constructor(scopedElements, {negated, nightwatchInstance}) {
method not (line 8) | get not() {
FILE: lib/api/web-element/assert/value-assertions.js
class ValueAssertions (line 5) | class ValueAssertions {
method constructor (line 6) | constructor(scopedValue, {negated}) {
method _assert (line 11) | _assert(callback) {
method not (line 39) | get not() {
method contains (line 46) | contains(expected, message) {
method equals (line 58) | equals(expected, message) {
method matches (line 70) | matches(expected, message) {
FILE: lib/api/web-element/element-locator.js
class ElementLocator (line 8) | class ElementLocator {
method constructor (line 9) | constructor(selector, options = {}) {
method create (line 19) | static create(selector, nightwatchInstance = {}) {
method getOrDefault (line 27) | static getOrDefault(obj, props, defaultValue) {
method getLocateStrategy (line 44) | static getLocateStrategy(element, strategy) {
method isElementDescriptor (line 56) | static isElementDescriptor(selector) {
method getSelectorValue (line 69) | static getSelectorValue(descriptor) {
method getCondition (line 85) | static getCondition(element, strategy) {
FILE: lib/api/web-element/element-value.js
class ScopedValue (line 3) | class ScopedValue {
method constructor (line 4) | constructor(value) {
method then (line 8) | then(onFulfilled, onRejected) {
method map (line 12) | map(callback) {
FILE: lib/api/web-element/factory.js
method get (line 37) | get() {
method value (line 48) | value(actionOrOptions, opts = {}) {
method value (line 71) | value(onFulfilled, onRejected) {
method get (line 79) | get() {
method value (line 87) | value(...args) {
method value (line 95) | value(...args) {
method value (line 103) | value(commandName, ...args) {
method get (line 113) | get() {
method value (line 121) | value(selector, parentElement = false) {
method value (line 134) | value(selector, {commandName, parentElement = false} = {}) {
method value (line 160) | value(onFulfilled, onRejected) {
method value (line 168) | value() {
method value (line 180) | value(index = 0) {
method value (line 218) | value(onFulfilled, onRejected) {
method value (line 226) | value(callback) {
method get (line 234) | get() {
method get (line 245) | get() {
FILE: lib/api/web-element/scoped-element.js
class ScopedWebElement (line 10) | class ScopedWebElement {
method methodAliases (line 12) | static get methodAliases() {
method getMethodNames (line 37) | static getMethodNames() {
method driver (line 57) | get driver() {
method reporter (line 61) | get reporter() {
method queue (line 65) | get queue() {
method __nightwatchScopedWebElement__ (line 69) | get __nightwatchScopedWebElement__() {
method suppressNotFoundErrors (line 73) | get suppressNotFoundErrors() {
method constructor (line 77) | constructor(selector = 'html', parentElement, nightwatchInstance) {
method waitUntilElementsLocated (line 87) | async waitUntilElementsLocated(selector) {
method locateElements (line 98) | async locateElements({parentElement, selector, timeout, retryInterval}) {
method findElementUsingRecursion (line 121) | async findElementUsingRecursion({parentElement, recursiveElement, time...
method findElement (line 144) | async findElement({parentElement, selector, index, timeout, retryInter...
method findElementAction (line 164) | async findElementAction({parentElement, condition, index, timeout, ret...
method createWebElementPromise (line 216) | createWebElementPromise({selector, parentElement}) {
method waitFor (line 270) | waitFor(promise, {isRoot = false} = {}) {
method createRootElementCommand (line 284) | createRootElementCommand(name, context, args) {
method createNode (line 290) | createNode(commandName, args) {
method runQueuedCommand (line 317) | runQueuedCommand(commandName, {args = [], namespace, isRoot = false, n...
method queueAction (line 327) | queueAction({name, createAction, namespace = 'element()', args = [], r...
method executeMethod (line 341) | executeMethod(context, methodName, ...args) {
method then (line 349) | then(onFulfilled, onRejected) {
function createNarrowedError (line 354) | function createNarrowedError({error, condition, timeout}) {
FILE: lib/api/web-element/scoped-elements.js
class ScopedElements (line 6) | class ScopedElements {
method constructor (line 7) | constructor(selector, parentScopedElement, nightwatchInstance) {
method findElementsUsingRecursion (line 34) | async findElementsUsingRecursion({parentElement, recursiveElement, tim...
method findElements (line 58) | async findElements({parentElement, selector, timeout, retryInterval}) {
method findElementsAction (line 71) | async findElementsAction(descriptor) {
method queueAction (line 122) | queueAction({name, commandFn, namespace = 'element()', args = [], reje...
method then (line 136) | then(onFulfilled, onRejected) {
FILE: lib/api/web-element/waitUntil.js
class WaitUntil (line 69) | class WaitUntil {
method constructor (line 70) | constructor(scopedElement, {action, timeout, retryInterval, message, n...
method createNode (line 83) | createNode() {
method wait (line 121) | async wait() {
method formatMsg (line 133) | formatMsg(message, timeMs) {
method assert (line 139) | assert({result, passed, err, message, elapsedTime}) {
method pass (line 147) | pass(result, elapsedTime) {
method fail (line 163) | fail(result, actual, elapsedTime) {
FILE: lib/assertion/assertion-error.js
class NightwatchAssertError (line 3) | class NightwatchAssertError extends AssertionError {
method constructor (line 4) | constructor(message) {
FILE: lib/assertion/assertion-runner.js
method isServerError (line 13) | static isServerError(result = {}) {
method constructor (line 26) | constructor(opts = {}) {
method create (line 31) | create() {
method run (line 57) | async run(commandResult = {value: null}) {
FILE: lib/assertion/assertion.js
class NightwatchAssertion (line 5) | class NightwatchAssertion {
method getExpectedMessage (line 6) | static getExpectedMessage({expected, actual}) {
method constructor (line 14) | constructor(message) {
method error (line 30) | get error() {
method stackTraceTitle (line 34) | set stackTraceTitle(val) {
method showTrace (line 38) | set showTrace(value) {
method link (line 42) | set link(value) {
method help (line 46) | set help(value) {
method stackTraceTitle (line 50) | get stackTraceTitle() {
method abortOnFailure (line 54) | set abortOnFailure(value) {
method abortOnFailure (line 59) | get abortOnFailure() {
method buildStackTrace (line 63) | buildStackTrace() {
method setFailedMessage (line 78) | setFailedMessage() {
method setMessage (line 86) | setMessage(needsExpected = true, elapsedTime) {
method getAssertResult (line 100) | getAssertResult() {
method captureStackTrace (line 120) | captureStackTrace(calleeFn) {
method assert (line 126) | assert() {
FILE: lib/core/asynctree.js
class AsyncTree (line 7) | class AsyncTree extends EventEmitter{
method started (line 8) | get started() {
method rootNode (line 12) | get rootNode() {
method inProgress (line 16) | get inProgress() {
method constructor (line 20) | constructor({compatMode, foreignRunner, cucumberRunner, mochaRunner}) {
method addNode (line 30) | addNode(node) {
method createRootNode (line 34) | createRootNode() {
method traverse (line 43) | async traverse(err) {
method walkUp (line 68) | async walkUp(err) {
method otherChildNodesInProgress (line 84) | otherChildNodesInProgress(node) {
method shouldAvoidParentNodeResolution (line 94) | shouldAvoidParentNodeResolution(node) {
method shouldRejectNodePromise (line 106) | shouldRejectNodePromise(err, abortOnFailure, node = this.currentNode) {
method shouldRejectParentNodePromise (line 120) | shouldRejectParentNodePromise(err, node = this.currentNode) {
method runChildNode (line 129) | async runChildNode(node) {
method resolveNode (line 188) | resolveNode(node, result, times = 0) {
method done (line 213) | async done(err = null) {
method empty (line 233) | empty() {
method reset (line 239) | reset() {
method getNextChildNode (line 250) | static getNextChildNode(node) {
method argFilters (line 265) | static get argFilters() {
method printArguments (line 279) | static printArguments(node) {
FILE: lib/core/client.js
class NightwatchAPI (line 21) | class NightwatchAPI {
method WEBDRIVER_ELEMENT_ID (line 22) | get WEBDRIVER_ELEMENT_ID() {
method browserName (line 26) | get browserName() {
method platformName (line 38) | get platformName() {
method toString (line 50) | toString() {
method constructor (line 54) | constructor(sessionId, settings) {
method __isBrowserName (line 66) | __isBrowserName(browser, alternateName) {
method __isPlatformName (line 83) | __isPlatformName(platform) {
method isIOS (line 91) | isIOS() {
method isAndroid (line 95) | isAndroid() {
method isMobile (line 99) | isMobile() {
method isSafari (line 103) | isSafari() {
method isChrome (line 107) | isChrome() {
method isFirefox (line 111) | isFirefox() {
method isEdge (line 115) | isEdge() {
method isInternetExplorer (line 119) | isInternetExplorer() {
method isOpera (line 123) | isOpera() {
method isAppiumClient (line 127) | isAppiumClient() {
class NightwatchClient (line 143) | class NightwatchClient extends EventEmitter {
method create (line 145) | static create(settings, argv) {
method constructor (line 175) | constructor(userSettings = {}, argv = {}) {
method overridableCommands (line 220) | get overridableCommands() {
method api (line 224) | get api() {
method argv (line 228) | get argv() {
method queue (line 232) | get queue() {
method locateStrategy (line 236) | get locateStrategy() {
method configLocateStrategy (line 240) | get configLocateStrategy() {
method sessionId (line 244) | get sessionId() {
method usingCucumber (line 248) | get usingCucumber() {
method getSessionId (line 256) | getSessionId() {
method sessionId (line 260) | set sessionId(val) {
method transport (line 264) | get transport() {
method transportActions (line 268) | get transportActions() {
method elementLocator (line 355) | get elementLocator() {
method httpOpts (line 359) | get httpOpts() {
method startSessionEnabled (line 363) | get startSessionEnabled() {
method unitTestingMode (line 367) | get unitTestingMode() {
method screenshotsEnabled (line 371) | screenshotsEnabled() {
method reporter (line 375) | get reporter() {
method client (line 379) | get client() {
method createApis (line 393) | createApis() {
method setApiProperty (line 420) | setApiProperty(key, value) {
method setApiOption (line 433) | setApiOption(key, value) {
method setApiMethod (line 445) | setApiMethod(key, ...args) {
method setNamespacedApiMethod (line 469) | setNamespacedApiMethod(key, ...args) {
method isApiMethodDefined (line 492) | isApiMethodDefined(key, namespace) {
method setReporter (line 505) | setReporter(reporter) {
method endSessionOnFail (line 517) | endSessionOnFail(val) {
method setLaunchUrl (line 525) | setLaunchUrl() {
method setScreenshotOptions (line 541) | setScreenshotOptions() {
method setConfigLocateStrategy (line 552) | setConfigLocateStrategy() {
method setLocateStrategy (line 558) | setLocateStrategy(strategy = null) {
method initialCapabilities (line 570) | get initialCapabilities() {
method setInitialCapabilities (line 578) | setInitialCapabilities(value) {
method setSessionOptions (line 586) | setSessionOptions() {
method mergeCapabilities (line 592) | mergeCapabilities(props = {}) {
method setHttpOptions (line 603) | setHttpOptions() {
method initialize (line 683) | async initialize(loadNightwatchApis = true) {
method setCurrentTest (line 693) | setCurrentTest() {
method loadKeyCodes (line 699) | loadKeyCodes() {
method loadNightwatchApis (line 705) | async loadNightwatchApis() {
method createTransport (line 726) | createTransport() {
method createCommandQueue (line 735) | createCommandQueue() {
method createSession (line 752) | createSession({argv, moduleKey = '', reuseBrowser = false} = {}) {
method startSession (line 778) | startSession() {
FILE: lib/core/queue.js
class CommandQueue (line 6) | class CommandQueue extends EventEmitter {
method constructor (line 7) | constructor({compatMode = false, foreignRunner = false, cucumberRunner...
method currentNode (line 15) | get currentNode() {
method started (line 19) | get started() {
method shouldStartQueue (line 23) | shouldStartQueue() {
method add (line 32) | add(command) {
method scheduleTraverse (line 74) | scheduleTraverse() {
method clearScheduled (line 82) | clearScheduled() {
method empty (line 88) | empty() {
method reset (line 94) | reset() {
method traverse (line 100) | traverse() {
method inProgress (line 119) | get inProgress() {
method done (line 123) | done(err) {
method waitForCompletion (line 140) | waitForCompletion() {
method run (line 148) | run(currentTestCaseResult) {
FILE: lib/core/treenode.js
class TreeNode (line 5) | class TreeNode {
method command (line 6) | get command() {
method context (line 10) | get context() {
method args (line 14) | get args() {
method instance (line 18) | get instance() {
method redact (line 22) | get redact() {
method isTraceable (line 26) | get isTraceable() {
method fullName (line 30) | get fullName() {
method isRootNode (line 38) | get isRootNode() {
method setCommand (line 49) | setCommand(commandFn, context, args, options = {}) {
method constructor (line 59) | constructor({name, parent, namespace, stackTrace, deferred, isES6Async...
method getResult (line 86) | getResult(result) {
method resolve (line 94) | resolve(result) {
method reject (line 103) | reject(reason) {
method run (line 112) | run() {
method handleError (line 116) | handleError(err) {
method runCommand (line 139) | async runCommand() {
method invokeCommand (line 157) | invokeCommand() {
method execute (line 166) | execute(autoInvoke = false) {
method handleCommandResult (line 202) | handleCommandResult(resolveFn, rejectFn) {
FILE: lib/element/appium-locator.js
class AppiumLocator (line 6) | class AppiumLocator extends LocateElement {
method create (line 11) | static create(element) {
FILE: lib/element/command.js
class ElementCommand (line 10) | class ElementCommand extends EventEmitter {
method isSelectorObject (line 11) | static isSelectorObject(obj) {
method ELEMENT_COMMAND_ARGS (line 15) | static get ELEMENT_COMMAND_ARGS() {
method api (line 19) | get api() {
method client (line 23) | get client() {
method settings (line 27) | get settings() {
method transport (line 31) | get transport() {
method desiredCapabilities (line 35) | get desiredCapabilities() {
method reporter (line 39) | get reporter() {
method commandName (line 43) | get commandName() {
method defaultUsing (line 47) | get defaultUsing() {
method strategy (line 51) | get strategy() {
method elementLocator (line 55) | get elementLocator() {
method rescheduleInterval (line 59) | get rescheduleInterval() {
method ms (line 63) | get ms() {
method retryOnSuccess (line 67) | get retryOnSuccess() {
method retryOnValidActionResult (line 71) | get retryOnValidActionResult() {
method callback (line 75) | get callback() {
method element (line 79) | get element() {
method selector (line 83) | get selector() {
method extraArgsCount (line 87) | get extraArgsCount() {
method abortOnFailure (line 91) | get abortOnFailure() {
method abortOnFailure (line 95) | set abortOnFailure(value) {
method suppressNotFoundErrors (line 99) | get suppressNotFoundErrors() {
method suppressNotFoundErrors (line 103) | set suppressNotFoundErrors(value) {
method protocolAction (line 111) | protocolAction() {
method isResultSuccess (line 115) | isResultSuccess(result) {
method protocolActionHandler (line 119) | protocolActionHandler() {
method constructor (line 123) | constructor({nightwatchInstance, commandName, args, requireValidation ...
method setupExecutor (line 148) | setupExecutor() {
method setupActions (line 155) | setupActions() {
method command (line 158) | command() {
method elementFound (line 167) | elementFound(response) {
method isSeleniumWebElement (line 181) | isSeleniumWebElement(value) {
method elementNotFound (line 189) | elementNotFound(err) {
method elementLocateError (line 193) | elementLocateError(err) {
method findElement (line 203) | async findElement({returnSingleElement = true, cacheElementId = true} ...
method executeProtocolAction (line 225) | executeProtocolAction(actionName, args = []) {
method complete (line 238) | async complete(err, response) {
method validateArgsCount (line 252) | validateArgsCount(requireValidation = true) {
method setStrategyFromArgs (line 290) | setStrategyFromArgs() {
method setArguments (line 297) | setArguments(requireValidation) {
method setOptionsFromSelector (line 308) | setOptionsFromSelector() {
method setStrategy (line 351) | setStrategy(val = this.defaultUsing) {
method setOutputMessage (line 357) | setOutputMessage() {
method setCallback (line 368) | setCallback() {
method createElement (line 382) | createElement() {
method setMilliseconds (line 393) | setMilliseconds(timeoutMs = this.api.globals.waitForConditionTimeout) {
method setRescheduleInterval (line 406) | setRescheduleInterval(intervalMs = this.api.globals.waitForConditionPo...
method noSuchElementError (line 413) | noSuchElementError(err) {
FILE: lib/element/index.js
class Element (line 5) | class Element {
method defaultProps (line 6) | static get defaultProps() {
method constructor (line 29) | constructor(definition, options = {}) {
method index (line 38) | get index() {
method index (line 42) | set index(val) {
method indexDisplay (line 46) | get indexDisplay() {
method usingRecursion (line 50) | get usingRecursion() {
method selector (line 54) | set selector(val) {
method selector (line 58) | get selector() {
method setProperties (line 66) | setProperties(definition, options) {
method getId (line 109) | getId() {
method setResolvedElement (line 113) | setResolvedElement(value) {
method toString (line 117) | toString() {
method hasElementSelector (line 146) | hasElementSelector() {
method getRecursiveLookupElement (line 159) | getRecursiveLookupElement() {
method copyDefaults (line 183) | static copyDefaults(target, source) {
method createFromSelector (line 201) | static createFromSelector(value, using) {
method requiresFiltering (line 271) | static requiresFiltering(element) {
method applyFiltering (line 286) | static applyFiltering(element, resultElements) {
method isElementObject (line 296) | static isElementObject(element) {
function hasValidValueIn (line 305) | function hasValidValueIn(definition) {
function getAncestorsWithElement (line 317) | function getAncestorsWithElement(element) {
function getDescription (line 337) | function getDescription(instance) {
FILE: lib/element/locate/elements-by-recursion.js
class MultipleElementsByRecursion (line 13) | class MultipleElementsByRecursion extends RecursiveLookupBase {
method transportAction (line 14) | get transportAction() {
method commandName (line 18) | get commandName() {
method locateElements (line 22) | locateElements({element, returnSingleElement}) {
FILE: lib/element/locate/recursive-lookup.js
class RecursiveLookupBase (line 11) | class RecursiveLookupBase extends EventEmitter {
method constructor (line 12) | constructor(nightwatchInstance) {
method getNextElement (line 20) | getNextElement() {
method createPromise (line 24) | createPromise() {
method shouldReturnSingleElement (line 36) | shouldReturnSingleElement(returnSingleElement) {
method recursiveElementLookup (line 44) | recursiveElementLookup({result, returnSingleElement}) {
method complete (line 82) | complete(result, callback) {
FILE: lib/element/locate/single-element-by-recursion.js
class SingleElementByRecursion (line 10) | class SingleElementByRecursion extends RecursiveLookupBase {
method transportAction (line 11) | get transportAction() {
method commandName (line 15) | get commandName() {
method locateElement (line 23) | locateElement(elements) {
FILE: lib/element/locator-factory.js
class NightwatchLocator (line 6) | class NightwatchLocator {
method create (line 12) | static create(element, isAppiumClient) {
FILE: lib/element/locator.js
constant AVAILABLE_LOCATORS (line 6) | const AVAILABLE_LOCATORS = {
class LocateElement (line 17) | class LocateElement {
method create (line 22) | static create(element) {
method locateInstanceOfBy (line 41) | static locateInstanceOfBy(element) {
method createElementInstance (line 61) | static createElementInstance(element) {
method api (line 79) | get api() {
method reporter (line 83) | get reporter() {
method settings (line 87) | get settings() {
method transport (line 91) | get transport() {
method desiredCapabilities (line 95) | get desiredCapabilities() {
method constructor (line 99) | constructor(nightwatchInstance) {
method resolveElementRecursively (line 103) | resolveElementRecursively({element}) {
method findElement (line 141) | async findElement({element, commandName, id, transportAction = 'locate...
method locateMultipleElements (line 172) | locateMultipleElements(element) {
method handleLocateElement (line 179) | handleLocateElement({result, element, returnSingleElement}) {
method executeProtocolAction (line 217) | executeProtocolAction(opts = {}) {
method sendElementsAction (line 256) | async sendElementsAction({transportAction, args, element, cacheElement...
method filterElements (line 293) | filterElements(element, result) {
method findElementsUsingRecursion (line 312) | findElementsUsingRecursion({element, returnSingleElement = true}) {
method findSingleElementUsingRecursion (line 318) | findSingleElementUsingRecursion(element) {
class NoSuchElementError (line 325) | class NoSuchElementError extends Error {
method constructor (line 326) | constructor({element, ms, abortOnFailure, retries}) {
FILE: lib/element/strategy.js
class LocateStrategy (line 3) | class LocateStrategy {
method Strategies (line 4) | static get Strategies() {
method isValid (line 22) | static isValid(strategy) {
method getList (line 28) | static getList() {
method XPATH (line 32) | static get XPATH() {
method CSS_SELECTOR (line 36) | static get CSS_SELECTOR() {
method getDefault (line 40) | static getDefault() {
method validate (line 44) | static validate(strategy, apiMethod) {
method Recursion (line 53) | static get Recursion() {
FILE: lib/http/auth.js
class Auth (line 3) | class Auth {
method constructor (line 4) | constructor(httpRequest) {
method basic (line 8) | basic(user, pass) {
method addAuth (line 12) | addAuth(user, pass) {
method toBase64 (line 18) | static toBase64(str) {
FILE: lib/http/formatter.js
class ResponseFormatter (line 4) | class ResponseFormatter {
method jsonStringify (line 13) | static jsonStringify(s) {
method stripUnknownChars (line 31) | static stripUnknownChars(str) {
method formatHostname (line 45) | static formatHostname(hostname, port, useSSL) {
FILE: lib/http/http.js
method isRedirect (line 30) | isRedirect(statusCode) {
method needsContentLengthHeader (line 39) | needsContentLengthHeader(requestMethod) {
FILE: lib/http/options.js
class HttpOptions (line 14) | class HttpOptions {
method settings (line 17) | get settings() {
method constructor (line 21) | constructor() {
method #updateSetting (line 25) | #updateSetting(key, value) {
method setPort (line 31) | setPort(port) {
method setHost (line 35) | setHost(value) {
method useSSL (line 39) | useSSL(value) {
method setKeepAlive (line 43) | setKeepAlive(value) {
method setCredentials (line 47) | setCredentials(credentials) {
method setProxy (line 51) | setProxy(proxy) {
method setDefaultPathPrefix (line 55) | setDefaultPathPrefix(path) {
method setTimeout (line 59) | setTimeout(timeout) {
method setRetryAttempts (line 63) | setRetryAttempts(retryAttempts) {
method setInternalServerRetryIntervel (line 67) | setInternalServerRetryIntervel(retryInterval) {
FILE: lib/http/request.js
class HttpRequest (line 35) | class HttpRequest extends EventEmitter {
method USER_AGENT (line 36) | static get USER_AGENT() {
method constructor (line 43) | constructor(opts) {
method globalSettings (line 58) | static set globalSettings(val) {
method resetHttpKeepAliveAgents (line 62) | static resetHttpKeepAliveAgents() {
method getAgent (line 66) | static getAgent({secure, keepAliveMsecs, maxSockets}) {
method globalSettings (line 85) | static get globalSettings() {
method updateGlobalSettings (line 89) | static updateGlobalSettings(settings = {}) {
method setHttpOpts (line 93) | setHttpOpts() {
method httpOpts (line 97) | get httpOpts() {
method socket (line 101) | get socket() {
method elapsedTime (line 105) | get elapsedTime() {
method statusCode (line 109) | get statusCode() {
method setOptions (line 113) | setOptions(options) {
method setData (line 139) | setData(options) {
method setPathPrefix (line 151) | setPathPrefix(options) {
method addKeepAliveOptions (line 158) | addKeepAliveOptions(reqOptions) {
method createHttpOptions (line 178) | createHttpOptions(options) {
method proxyEvents (line 211) | proxyEvents(originalIssuer, events) {
method createHttpRequest (line 231) | createHttpRequest() {
method logRequest (line 249) | logRequest() {
method logError (line 275) | logError(err) {
method onRequestComplete (line 286) | onRequestComplete(result, response) {
method logResponse (line 332) | logResponse(result) {
method onRequestError (line 361) | onRequestError(err) {
method shouldRetryRequest (line 380) | shouldRetryRequest(err) {
method post (line 384) | post() {
method delete (line 390) | delete() {
method send (line 396) | send() {
method addHeaders (line 426) | addHeaders() {
method setProxyIfNeeded (line 444) | setProxyIfNeeded() {
method setFormData (line 460) | setFormData(boundary) {
method hasCredentials (line 488) | hasCredentials() {
method addAuthorizationIfNeeded (line 492) | addAuthorizationIfNeeded(req) {
function isRetryableNetworkError (line 511) | function isRetryableNetworkError(err) {
FILE: lib/http/response.js
class HttpResponse (line 6) | class HttpResponse extends EventEmitter {
method constructor (line 13) | constructor(response, request) {
method handle (line 25) | handle() {
method flushResponse (line 65) | flushResponse() {
method isResponseJson (line 74) | isResponseJson() {
method isServerError (line 78) | isServerError() {
method parseResponseData (line 82) | parseResponseData(data) {
FILE: lib/index.js
method updateCapabilities (line 133) | updateCapabilities(value) {
method runGlobalBeforeHook (line 137) | runGlobalBeforeHook() {
method runGlobalAfterHook (line 141) | runGlobalAfterHook() {
method launchBrowser (line 145) | launchBrowser({loadNightwatchApis = true} = {}) {
method cleanup (line 174) | async cleanup() {
method get (line 363) | get() {
method get (line 396) | get() {
function throwIfBrowserNotAvailable (line 401) | function throwIfBrowserNotAvailable() {
method get (line 411) | get() {
method get (line 418) | get() {
method get (line 443) | get(_, name) {
method get (line 448) | get(_, name) {
method apply (line 453) | apply(_, __, args) {
method get (line 458) | get(_, name) {
method apply (line 466) | apply(_, __, args) {
method get (line 471) | get(_, name) {
method get (line 480) | get() {
FILE: lib/page-object/base-object.js
class BaseObject (line 5) | class BaseObject {
method WrappedProtocolCommands (line 6) | static get WrappedProtocolCommands() {
method createProps (line 21) | static createProps(parent, val = {}) {
method createElements (line 32) | static createElements(parent, elements = []) {
method createSections (line 64) | static createSections(parent, sections = {}) {
method addCommands (line 86) | static addCommands(parent, commands) {
method addCommandsFromClass (line 109) | static addCommandsFromClass(parent, CommandClass) {
method createPageCommandInstance (line 127) | static createPageCommandInstance(CommandClass, page) {
FILE: lib/page-object/command-wrapper.js
constant ALLOWED_NAMESPACES (line 4) | const ALLOWED_NAMESPACES = [
function isAllowedNamespace (line 9) | function isAllowedNamespace(commandName) {
class Command (line 13) | class Command {
method TYPE_ELEMENT (line 14) | static get TYPE_ELEMENT() {
method TYPE_SECTION (line 18) | static get TYPE_SECTION() {
method isPossibleElementSelector (line 22) | static isPossibleElementSelector(item, commandName = '') {
method isUserDefinedElementCommand (line 42) | static isUserDefinedElementCommand(commandName) {
method constructor (line 48) | constructor(parent, commandName, isChaiAssertion, isES6Async = false) {
method createWrapper (line 65) | createWrapper(commandFn) {
method validate (line 119) | validate(elementOrSection, strategy, type) {
method getElement (line 166) | getElement(elementName, strategy = null) {
method getSection (line 179) | getSection(sectionName, strategy = null) {
method getSelectorFromArgs (line 185) | getSelectorFromArgs(args) {
method parseElementSelector (line 213) | parseElementSelector(args) {
method executeCommand (line 271) | executeCommand(commandFn, args, context) {
class CommandLoader (line 285) | class CommandLoader {
method addWrappedCommands (line 294) | static addWrappedCommands(parent, commandLoader) {
method addWrappedCommandsAsync (line 311) | static addWrappedCommandsAsync(parent, commandLoader) {
method applyCommandsToTarget (line 328) | static applyCommandsToTarget(parent, target, commands) {
method wrapElementCommand (line 370) | static wrapElementCommand(parent, originalApi, targetApi, commandName) {
method wrapProtocolCommands (line 403) | static wrapProtocolCommands(parent, api, commands) {
method wrapScopedElementApi (line 409) | static wrapScopedElementApi(parent, api, elementCommands) {
method addCommand (line 426) | static addCommand({target, commandFn, commandName, parent, isChaiAsser...
FILE: lib/page-object/index.js
class Page (line 41) | class Page extends BaseObject {
method constructor (line 42) | constructor(options, commandLoader, client) {
method api (line 70) | get api() {
method client (line 74) | get client() {
method name (line 78) | get name() {
method props (line 85) | get props() {
method elements (line 92) | get elements() {
method section (line 99) | get section() {
method url (line 103) | get url() {
method url (line 107) | set url(val) {
method getUrl (line 119) | get getUrl() {
method navigate (line 152) | get navigate() {
FILE: lib/page-object/section.js
class Section (line 12) | class Section extends Element {
method section (line 13) | get section() {
method createApiShallowCopy (line 20) | createApiShallowCopy() {
method constructor (line 25) | constructor(definition, options) {
FILE: lib/reporter/axe-report.js
method createTable (line 54) | static createTable() {
method constructor (line 78) | constructor(report, {detailedReport = true, includeHtml = true} = {}) {
method hasViolations (line 84) | hasViolations() {
method printPasses (line 88) | printPasses() {
method printViolations (line 143) | printViolations(component) {
FILE: lib/reporter/base-reporter.js
method constructor (line 7) | constructor(results, opts = {}) {
method adaptAssertions (line 12) | adaptAssertions(module) {
method writeReportFile (line 67) | writeReportFile(filename, rendered, shouldCreateFolder, output_folder) {
method writeReport (line 85) | async writeReport(moduleKey) {}
method write (line 87) | write() {
FILE: lib/reporter/global-reporter.js
method initialReport (line 17) | static get initialReport() {
method constructor (line 35) | constructor(reporter = DefaultSettings.default_reporter, settings, {open...
method registerUncaughtErr (line 55) | registerUncaughtErr(err) {
method isDisabled (line 59) | isDisabled() {
method hasTestFailures (line 63) | hasTestFailures() {
method addTestSuiteResults (line 69) | addTestSuiteResults(testResults, httpOutput) {
method setupChildProcessListener (line 86) | setupChildProcessListener(emitter) {
method create (line 95) | create(startTime) {
method print (line 115) | print() {
method loadReporter (line 148) | loadReporter() {
method printA11yReport (line 154) | printA11yReport() {
method loadFile (line 179) | async loadFile(reporterFile) {
method loadCustomReporter (line 190) | async loadCustomReporter(reporterFile) {
method writeReportToFile (line 218) | async writeReportToFile(globalResults) {
method writeReport (line 238) | async writeReport(reporter, globalResults) {
method shouldShowSummary (line 268) | shouldShowSummary() {
method hasAssertionCount (line 281) | hasAssertionCount() {
method getTotalTestsCount (line 287) | getTotalTestsCount() {
method getTestsFailedMessage (line 296) | getTestsFailedMessage() {
method getTestsPassedMessage (line 327) | getTestsPassedMessage() {
method getPluginReporters (line 343) | getPluginReporters() {
method getTimeoutValueMs (line 363) | getTimeoutValueMs(customReporter) {
method callReporterFn (line 378) | callReporterFn(reporter, globalResults, {callbackTimeoutId, resolve, rej...
method runCustomGlobalReporter (line 410) | runCustomGlobalReporter(globalResults) {
method save (line 462) | save() {
FILE: lib/reporter/index.js
class Reporter (line 9) | class Reporter extends SimplifiedReporter {
method printAssertions (line 10) | static printAssertions(testcase) {
method constructor (line 27) | constructor({settings, tests, suiteRetries, addOpts = {}, skippedTests...
method currentTest (line 50) | get currentTest() {
method currentSection (line 54) | get currentSection() {
method printA11Report (line 58) | get printA11Report() {
method setCurrentTest (line 66) | setCurrentTest(testcase, context) {
method setCurrentSection (line 74) | setCurrentSection(testcase) {
method markHookRun (line 81) | markHookRun(hookName) {
method unmarkHookRun (line 85) | unmarkHookRun(hookName) {
method setAxeResults (line 89) | setAxeResults(results) {
method printA11yReport (line 93) | printA11yReport() {
method resetCurrentTestName (line 97) | resetCurrentTestName() {
method unitTestsMode (line 101) | get unitTestsMode() {
method currentTestCasePassed (line 105) | get currentTestCasePassed() {
method allTestsPassed (line 109) | get allTestsPassed() {
method shouldIncrementTotalCount (line 118) | shouldIncrementTotalCount(err) {
method setFileNamePrefix (line 131) | setFileNamePrefix(prefix) {
method setSessionInfo (line 135) | setSessionInfo(data) {
method setElapsedTime (line 140) | setElapsedTime() {
method setTestSectionElapsedTime (line 144) | setTestSectionElapsedTime() {
method setTestStatus (line 148) | setTestStatus() {
method collectTestSectionOutput (line 152) | collectTestSectionOutput() {
method testSuiteFinished (line 156) | testSuiteFinished() {
method exportResults (line 160) | exportResults() {
method logTestCase (line 173) | logTestCase(testName) {
method logAssertResult (line 193) | logAssertResult(result) {
method logCommandResult (line 201) | logCommandResult({node, result}) {
method stringifyArgs (line 255) | static stringifyArgs(args) {
method shouldLogCommand (line 273) | shouldLogCommand(node) {
method registerPassed (line 289) | registerPassed(message) {
method registerFailed (line 294) | registerFailed(err) {
method registerTestError (line 302) | registerTestError(err) {
method resetCurrentTestPassedCount (line 321) | resetCurrentTestPassedCount() {
method printTestResult (line 327) | printTestResult() {
method printSimplifiedTestResult (line 361) | printSimplifiedTestResult(ok, elapsedTime, isWorker) {
method getFailureMessage (line 395) | getFailureMessage() {
method saveErrorScreenshot (line 428) | saveErrorScreenshot(result, screenshotContent) {
FILE: lib/reporter/reporters/html.js
class HtmlReporter (line 11) | class HtmlReporter extends BaseReporter {
method hookNames (line 12) | static get hookNames(){
method ansiConverter (line 16) | static get ansiConverter(){
method openReporter (line 20) | openReporter(fileName) {
method getFolderPrefix (line 27) | getFolderPrefix() {
method getFileName (line 41) | getFileName() {
method computePassedAndFailedCounts (line 55) | computePassedAndFailedCounts(module) {
method createInitialResult (line 78) | createInitialResult(module) {
method aggregateEnvironments (line 101) | aggregateEnvironments(testEnv, moduleKey, module) {
method aggregateStats (line 124) | aggregateStats() {
method getGlobalMetadata (line 148) | getGlobalMetadata() {
method adaptModule (line 154) | adaptModule(module) {
method adaptResults (line 225) | adaptResults() {
method writeReport (line 254) | async writeReport() {
method write (line 277) | write(results, options, callback) {
method adaptResults (line 290) | adaptResults(results, options) {
FILE: lib/reporter/reporters/json.js
class JsonReporter (line 7) | class JsonReporter extends BaseReporter {
method writeReport (line 9) | writeReport(moduleKey, data = {}) {
method write (line 46) | write(results, options) {
FILE: lib/reporter/reporters/junit.js
class JUnitReporter (line 15) | class JUnitReporter extends BaseReporter {
method templateFile (line 16) | static get templateFile() {
method tmplData (line 20) | static set tmplData(val) {
method tmplData (line 24) | static get tmplData() {
method loadTemplate (line 28) | static loadTemplate() {
method writeReport (line 45) | writeReport(moduleKey, data) {
method write (line 87) | write() {
method write (line 103) | write(results, options, callback) {
FILE: lib/reporter/reporters/minimalJson.js
class MinimalJsonReporter (line 7) | class MinimalJsonReporter extends BaseReporter {
method adaptModule (line 9) | adaptModule(module) {
method adaptResults (line 19) | adaptResults() {
method writeReport (line 30) | writeReport() {
function write (line 52) | function write(results, options, callback) {
FILE: lib/reporter/results.js
method TEST_FAIL (line 9) | static get TEST_FAIL() {
method TEST_PASS (line 13) | static get TEST_PASS() {
method TEST_SKIP (line 17) | static get TEST_SKIP() {
method constructor (line 21) | constructor(tests = [], opts, settings, skippedTests = [], allScreenedTe...
method markHookRun (line 69) | markHookRun(hookName) {
method unmarkHookRun (line 84) | unmarkHookRun() {
method initialResult (line 118) | get initialResult() {
method currentTestResult (line 123) | get currentTestResult() {
method uuid (line 132) | get uuid() {
method currentTest (line 139) | set currentTest(value) {
method getTestResult (line 143) | getTestResult(testName, {returnFullResult = false} = {}) {
method getTestSection (line 173) | getTestSection(testName) {
method getCurrentTest (line 184) | getCurrentTest() {
method currentTest (line 189) | get currentTest() {
method currentSection (line 206) | get currentSection() {
method testSectionHasFailures (line 213) | testSectionHasFailures(testSection) {
method passedCount (line 220) | get passedCount() {
method failedCount (line 224) | get failedCount() {
method errorsCount (line 228) | get errorsCount() {
method skippedCount (line 232) | get skippedCount() {
method timestamp (line 236) | get timestamp() {
method testsCount (line 240) | get testsCount() {
method lastError (line 244) | get lastError() {
method stackTrace (line 248) | get stackTrace() {
method currentTestElapsedTime (line 252) | get currentTestElapsedTime() {
method currentTestCasePassed (line 256) | get currentTestCasePassed() {
method currentTestCaseHasFailures (line 260) | get currentTestCaseHasFailures() {
method export (line 270) | get export() {
method initCurrentTest (line 338) | initCurrentTest(testcase) {
method resetCurrentTestName (line 344) | resetCurrentTestName() {
method resetCurrentSectionName (line 354) | resetCurrentSectionName() {
method getCurrentTestName (line 360) | getCurrentTestName() {
method retryTest (line 367) | set retryTest(value) {
method retryTest (line 371) | get retryTest() {
method createTestCaseResults (line 379) | createTestCaseResults(testcase) {
method resetLastError (line 412) | resetLastError() {
method setLastError (line 416) | setLastError(err, {incrementTotal, addToErrArray = false} = {}) {
method incrementErrorCount (line 442) | incrementErrorCount(incrementTotal = true) {
method incrementFailedCount (line 466) | incrementFailedCount(incrementTotal = true) {
method incrementPassedCount (line 484) | incrementPassedCount() {
method subtractPassedCount (line 500) | subtractPassedCount(count = 0) {
method logAssertion (line 510) | logAssertion(assertion) {
method logCommand (line 520) | logCommand(command) {
method initCount (line 533) | initCount(allScreenedTests) {
method setElapsedTime (line 544) | setElapsedTime() {
method setTestSectionElapsedTime (line 561) | setTestSectionElapsedTime() {
method setTestStatus (line 581) | setTestStatus() {
method collectTestSectionOutput (line 604) | collectTestSectionOutput() {
method setTotalElapsedTime (line 613) | setTotalElapsedTime() {
method setCurrentTest (line 626) | setCurrentTest(testcase) {
method setCurrentSection (line 646) | setCurrentSection(testcase) {
method setSeleniumLogFile (line 653) | setSeleniumLogFile(outputFilePath) {
method logScreenshotFile (line 657) | logScreenshotFile(screenshotFile) {
method testsPassed (line 667) | testsPassed() {
method getTestStatus (line 671) | getTestStatus() {
method appendTestResult (line 690) | appendTestResult(data) {
method createGlobalReport (line 701) | static createGlobalReport(suiteResultsArr, initialReport) {
method eventDataToEmit (line 731) | get eventDataToEmit() {
FILE: lib/reporter/simplified.js
class SimplifiedReporter (line 4) | class SimplifiedReporter {
method logError (line 5) | static logError(err) {
method currentTestCase (line 17) | get currentTestCase() {
method constructor (line 24) | constructor(settings) {
method logAssertResult (line 29) | logAssertResult(test) {
method logCommandResult (line 36) | logCommandResult(node, result) {
method logFailedAssertion (line 40) | logFailedAssertion(err) {
method registerPassed (line 47) | registerPassed(message) {
method registerFailed (line 51) | registerFailed(err) {
method registerTestError (line 55) | registerTestError(err) {}
method saveErrorScreenshot (line 56) | saveErrorScreenshot(result, screenshotContent) {}
FILE: lib/reporter/summary.js
method failed (line 6) | static failed(test) {
method getTestcaseHeader (line 10) | static getTestcaseHeader(testcase, testcaseName) {
method getFailedSuiteContent (line 27) | static getFailedSuiteContent({testSuite, testSuiteName, index = 0, start...
method printSuite (line 59) | static printSuite(content) {
method printErrors (line 73) | static printErrors(testSuite) {
method printSkipped (line 99) | static printSkipped(testSuite) {
method constructor (line 119) | constructor(settings) {
method shouldPrintAssertions (line 123) | static shouldPrintAssertions(testcase) {
method print (line 127) | print(globalResults) {
FILE: lib/runner/androidEmulator.js
method constructor (line 6) | constructor (AVD) {
method killEmulator (line 13) | async killEmulator() {
method launchEmulator (line 17) | async launchEmulator() {
FILE: lib/runner/cli/argv-setup.js
class ArgvSetup (line 12) | class ArgvSetup {
method argv (line 13) | get argv() {
method constructor (line 35) | constructor(processArgs, cwd = process.cwd()) {
method addDefault (line 58) | addDefault(key, value) {
method isDefault (line 70) | isDefault(option, value) {
method getDefault (line 74) | getDefault(option) {
method alias (line 78) | alias(x, y) {
method demand (line 90) | demand(keys) {
method showUsage (line 107) | showUsage(msg) {
method describe (line 113) | describe(key, desc, groupName) {
method option (line 125) | option(key, opt) {
method showHelp (line 152) | showHelp(fn) {
method help (line 160) | help() {
method fail (line 232) | fail(msg) {
method setup (line 242) | setup() {
function longest (line 506) | function longest(xs) {
function rebase (line 510) | function rebase(base, dir) {
FILE: lib/runner/cli/cli.js
class CliRunner (line 18) | class CliRunner {
method CONFIG_FILE_JS (line 19) | static get CONFIG_FILE_JS() {
method CONFIG_FILE_CJS (line 23) | static get CONFIG_FILE_CJS() {
method CONFIG_FILE_TS (line 27) | static get CONFIG_FILE_TS() {
method createDefaultConfig (line 31) | static createDefaultConfig(destFileName) {
method constructor (line 89) | constructor(argv = {}) {
method initTestSettings (line 121) | initTestSettings(userSettings = {}, baseSettings = null, argv = null, ...
method globalsSetup (line 141) | globalsSetup(argv) {
method setTimeoutOptions (line 146) | setTimeoutOptions(argv) {
method setMobileOptions (line 156) | setMobileOptions(argv) {
method setupGlobalHooks (line 176) | setupGlobalHooks() {
method readExternalHooks (line 180) | readExternalHooks(asyncLoading = true) {
method settings (line 190) | get settings() {
method setCurrentTestEnv (line 194) | setCurrentTestEnv() {
method setLoggingOptions (line 211) | setLoggingOptions() {
method setupAsync (line 221) | async setupAsync(settings) {
method setup (line 233) | setup(settings) {
method commonSetup (line 240) | commonSetup(settings, asyncLoading = true) {
method runnerSetup (line 254) | runnerSetup() {
method isRegisterEventHandlersCallbackExistsInGlobal (line 274) | isRegisterEventHandlersCallbackExistsInGlobal() {
method setupEventHub (line 281) | setupEventHub() {
method loadTypescriptTranspiler (line 304) | loadTypescriptTranspiler() {
method isConfigDefault (line 312) | isConfigDefault(configFile, localJsValue = CliRunner.CONFIG_FILE_JS) {
method getLocalConfigFileName (line 316) | getLocalConfigFileName() {
method loadConfig (line 339) | loadConfig() {
method validateConfig (line 369) | validateConfig() {
method parseTestSettings (line 385) | parseTestSettings(settings = {}, asyncLoading = true) {
method runGlobalHook (line 396) | runGlobalHook(key, args = [], isParallelHook = false) {
method validateTestEnvironments (line 424) | validateTestEnvironments() {
method testWorkersMode (line 442) | get testWorkersMode() {
method usingServer (line 446) | usingServer(test_settings = {}) {
method isTestWorkersEnabled (line 452) | isTestWorkersEnabled() {
method parallelMode (line 495) | parallelMode() {
method setupConcurrency (line 499) | setupConcurrency() {
method isConcurrencyEnabled (line 510) | isConcurrencyEnabled() {
method executeTestRunner (line 518) | executeTestRunner(modules) {
method createTestRunner (line 522) | createTestRunner() {
method testEnvSettings (line 535) | get testEnvSettings() {
method getTestsFiles (line 547) | async getTestsFiles() {
method runTests (line 561) | runTests(done = null) {
FILE: lib/runner/concurrency/child-process.js
class ChildProcess (line 9) | class ChildProcess extends EventEmitter {
method defaultStartDelay (line 10) | static get defaultStartDelay() {
method prevIndex (line 14) | static get prevIndex() {
method prevIndex (line 18) | static set prevIndex(val) {
method constructor (line 22) | constructor(environment, index, env_output, settings, args) {
method setLabel (line 38) | setLabel(label) {
method printLog (line 45) | printLog(msg) {
method getChildProcessEnvKey (line 52) | getChildProcessEnvKey(env) {
method getArgs (line 61) | getArgs() {
method writeToStdout (line 81) | writeToStdout(data) {
method run (line 119) | run(colors, type) {
FILE: lib/runner/concurrency/index.js
class Concurrency (line 9) | class Concurrency extends EventEmitter {
method constructor (line 10) | constructor(settings = {}, argv = {}, isTestWorkerEnabled, isSafariEnv...
method getChildProcessArgs (line 22) | static getChildProcessArgs(envs) {
method createChildProcess (line 47) | createChildProcess(label, args = [], extraArgs = [], index = 0) {
method runChildProcess (line 67) | runChildProcess(childProcess, outputLabel, availColors, type) {
method runChildProcesses (line 84) | runChildProcesses(envs, modules) {
method runMultiple (line 121) | runMultiple(envs = [], modules) {
method runWorkerProcesses (line 144) | runWorkerProcesses(envs, modules) {
method runProcessTestEnvironment (line 182) | runProcessTestEnvironment(envs, args, availColors) {
method runWorkerTestEnvironments (line 200) | runWorkerTestEnvironments(envs, availColors) {
method runMultipleTestProcess (line 233) | runMultipleTestProcess(modules, args, availColors) {
method runMultipleTestWorkers (line 275) | runMultipleTestWorkers(modules, availColors) {
method setupWorkerPool (line 320) | setupWorkerPool(args, settings, maxWorkerCount) {
method printChildProcessOutput (line 332) | printChildProcessOutput(label) {
method getTestWorkersCount (line 360) | getTestWorkersCount() {
method buildProcessQueue (line 376) | static buildProcessQueue(maxWorkers, modules, fn) {
method getAvailableColors (line 403) | static getAvailableColors() {
method isWorker (line 428) | static isWorker() {
method isTestWorker (line 432) | static isTestWorker(argv = {}) {
method isMasterProcess (line 436) | static isMasterProcess() {
FILE: lib/runner/concurrency/task.js
function runWorkerTask (line 2) | function runWorkerTask({argv, port1}) {
FILE: lib/runner/concurrency/worker-process.js
constant WORKER_FILE (line 7) | const WORKER_FILE = path.resolve(__dirname, 'task.js');
class WorkerPool (line 9) | class WorkerPool extends EventEmitter {
method isWorkerThread (line 12) | static get isWorkerThread() {
method tasks (line 16) | get tasks() {
method tasks (line 20) | set tasks(tasks) {
method constructor (line 24) | constructor(args, settings, maxWorkerCount) {
method addTask (line 45) | addTask({label, argv, colors} = {}) {
FILE: lib/runner/concurrency/worker-task.js
class WorkerTask (line 9) | class WorkerTask extends EventEmitter {
method prevIndex (line 11) | static get prevIndex() {
method prevIndex (line 15) | static set prevIndex(val) {
method constructor (line 19) | constructor({piscina, index, label, settings, argv, task_ouput}) {
method printLog (line 33) | printLog(msg) {
method setlabel (line 40) | setlabel(colorPair) {
method writeToStdOut (line 44) | writeToStdOut(data) {
method runWorkerTask (line 68) | async runWorkerTask(colors, type) {
FILE: lib/runner/eventHub.js
class NightwatchEventHub (line 6) | class NightwatchEventHub extends EventEmitter {
method emit (line 7) | emit(eventName, data) {
method isAvailable (line 28) | get isAvailable() {
method isAvailable (line 32) | set isAvailable(eventFnExist) {
method runner (line 36) | set runner(type) {
method runner (line 40) | get runner() {
method writeReportFile (line 44) | writeReportFile(filename, rendered, shouldCreateFolder, output_folder) {
FILE: lib/runner/folder-walk.js
class Results (line 8) | class Results {
method constructor (line 9) | constructor() {
method getData (line 13) | getData() {
method register (line 17) | register(sourcePath) {
class Walker (line 32) | class Walker {
method constructor (line 33) | constructor(testSource = [], settings, argv = {}) {
method promise (line 52) | get promise() {
method disableTs (line 56) | get disableTs() {
method isComponentTestingMode (line 60) | isComponentTestingMode() {
method validateSource (line 64) | validateSource() {
method registerMatchers (line 87) | registerMatchers() {
method applyFilters (line 105) | applyFilters(list) {
method applyTagFilter (line 131) | async applyTagFilter(list) {
method promiseFn (line 153) | promiseFn(resolve, reject) {
method createPromise (line 211) | createPromise() {
method readTestSource (line 217) | readTestSource() {
method readFolderDeep (line 225) | readFolderDeep(folderPath) {
FILE: lib/runner/matchers/filename.js
class MatcherExclude (line 10) | class MatcherExclude {
method constructor (line 11) | constructor({pattern, settings, argv}) {
method adaptFilterPattern (line 17) | adaptFilterPattern(pattern) {
method match (line 48) | match(fullPath) {
class FilenameMatcher (line 53) | class FilenameMatcher {
method TYPE_EXCLUDE (line 54) | static get TYPE_EXCLUDE() {
method TYPE_FILTER (line 58) | static get TYPE_FILTER() {
method create (line 62) | static create({type, pattern, settings, argv}) {
method isFolderExcluded (line 70) | static isFolderExcluded(resource, opts) {
method addMatcher (line 90) | static addMatcher(type, {settings, argv}) {
method register (line 97) | static get register() {
FILE: lib/runner/matchers/tags.js
class TagsMatcher (line 5) | class TagsMatcher {
method SEPARATOR (line 6) | static get SEPARATOR() {
method constructor (line 10) | constructor(settings) {
method match (line 21) | async match(testFilePath) {
method loadModule (line 42) | async loadModule(modulePath) {
method checkModuleTags (line 80) | checkModuleTags(context) {
method matchesIncludeTagFilter (line 97) | matchesIncludeTagFilter(moduleTags) {
method hasIncludeTagFilter (line 104) | hasIncludeTagFilter() {
method hasSkipTagFilter (line 111) | hasSkipTagFilter() {
method anyTagsDefined (line 118) | anyTagsDefined() {
method convertTags (line 126) | static convertTags(tags) {
method convertFilterTags (line 143) | static convertFilterTags(tags) {
FILE: lib/runner/process-listener.js
method constructor (line 6) | constructor(proc = process) {
method addExitListener (line 20) | addExitListener() {
method setTestRunner (line 35) | setTestRunner(testRunner) {
method setExitCode (line 41) | setExitCode(code) {
method exitCode (line 47) | get exitCode() {
method onExit (line 51) | onExit(code) {
method unhandled (line 55) | unhandled(err) {
method getCurrentPromise (line 59) | getCurrentPromise(err) {
method uncaught (line 82) | uncaught(err, {type = 'uncaughtException'} = {}) {
method closeProcess (line 104) | closeProcess(err) {
method exit (line 112) | exit() {
FILE: lib/runner/rerunUtil.js
function getRerunFailedFile (line 4) | function getRerunFailedFile(minimal_report_file_path) {
function getTestSourceForRerunFailed (line 23) | function getTestSourceForRerunFailed(settings) {
FILE: lib/runner/runner.js
class Runner (line 4) | class Runner {
method NIGHTWATCH_RUNNER (line 5) | static get NIGHTWATCH_RUNNER() {
method DEFAULT_RUNNER (line 9) | static get DEFAULT_RUNNER() {
method MOCHA_RUNNER (line 13) | static get MOCHA_RUNNER() {
method CUCUMBER_RUNNER (line 17) | static get CUCUMBER_RUNNER() {
method createError (line 21) | static createError(err) {
method checkTestSource (line 40) | static checkTestSource(modules, testSource, settings) {
method getTestSource (line 73) | static getTestSource(settings, argv = {}) {
method readTestSource (line 79) | static readTestSource(settings, argv = {}) {
method create (line 100) | static create(settings, argv, addtOpts) {
FILE: lib/runner/test-runners/cucumber.js
class CucumberSuite (line 9) | class CucumberSuite extends TestSuite {
method isSessionCreateError (line 10) | static isSessionCreateError(err) {
method createCli (line 17) | static createCli(settings) {
method cucumberSetupFile (line 40) | static get cucumberSetupFile() {
method constructor (line 44) | constructor({modulePath, modules, settings, argv}) {
method createCucumberCli (line 82) | createCucumberCli() {
method shouldUseNightwatchFormatter (line 94) | shouldUseNightwatchFormatter(options) {
method getCliArgvForCucumber (line 101) | getCliArgvForCucumber() {
method createInitialRequires (line 128) | createInitialRequires() {
method mergeCliConfigValues (line 149) | mergeCliConfigValues(key) {
method buildArgvValue (line 158) | buildArgvValue(argNames) {
method onTestSuiteFinished (line 205) | onTestSuiteFinished(result) {
method testSuiteFinished (line 211) | testSuiteFinished() {}
method runTestSuite (line 213) | async runTestSuite() {
class CucumberRunnner (line 247) | class CucumberRunnner extends Runner {
method supportsConcurrency (line 248) | get supportsConcurrency() {
method supportsParallelTestSuiteRun (line 252) | get supportsParallelTestSuiteRun() {
method type (line 256) | get type() {
method constructor (line 260) | constructor(settings, argv, addtOpts) {
method hasTestFailures (line 279) | hasTestFailures(result) {
method createTestSuite (line 283) | createTestSuite({modulePath, modules}) {
method runTests (line 289) | async runTests(modules) {
FILE: lib/runner/test-runners/cucumber/nightwatch-format.js
method constructor (line 15) | constructor(options) {
method setCapabilities (line 27) | static setCapabilities(data) {
method onSessionCapabilities (line 50) | onSessionCapabilities(envelope) {
method onMeta (line 56) | onMeta(meta) {
method onGherkinDocument (line 60) | onGherkinDocument(gherkinDocument) {
method onParseError (line 64) | onParseError(parseError) {
method onPickle (line 68) | onPickle(pickle) {
method onHook (line 72) | onHook(hook) {
method onSource (line 76) | onSource(source) {
method onStepDefinition (line 80) | onStepDefinition(stepDefinition) {
method onTestCase (line 84) | onTestCase(testCase) {
method onTestCaseFinished (line 88) | onTestCaseFinished(result) {
method onTestCaseStarted (line 100) | onTestCaseStarted(result) {
method onTestRunFinished (line 110) | onTestRunFinished(result) {
method onTestRunStarted (line 120) | onTestRunStarted(result) {
method onTestStepFinished (line 129) | onTestStepFinished(result) {
method onTestStepStarted (line 140) | onTestStepStarted(result) {
method reportHandler (line 150) | reportHandler(envelope) {
FILE: lib/runner/test-runners/default.js
class DefaultRunner (line 6) | class DefaultRunner {
method supportsConcurrency (line 7) | get supportsConcurrency() {
method type (line 11) | get type() {
method constructor (line 15) | constructor(settings, argv, addtOpts) {
method client (line 27) | get client() {
method results (line 31) | get results() {
method hasTestFailures (line 35) | hasTestFailures() {
method registerUncaughtErr (line 39) | registerUncaughtErr(err) {
method closeOpenSessions (line 47) | closeOpenSessions(err) {
method createTestSuite (line 64) | async createTestSuite({modulePath, modules}) {
method runTestSuite (line 73) | async runTestSuite(modulePath, modules) {
method promiseFn (line 97) | async promiseFn(resolve, reject) {
method printGlobalResults (line 113) | printGlobalResults() {
method runTests (line 123) | runTests(modules) {
method reportResults (line 133) | async reportResults() {
method runConcurrent (line 146) | async runConcurrent(testEnvArray, modules, isTestWorkerEnabled, isSafa...
method isTestWorker (line 156) | isTestWorker() {
method run (line 165) | async run(modules) {
FILE: lib/runner/test-runners/mocha.js
class MochaRunner (line 7) | class MochaRunner {
method MochaNightwatch (line 8) | static MochaNightwatch({argv, settings, addtOpts}) {
method supportsConcurrency (line 31) | get supportsConcurrency() {
method combinedReporterList (line 35) | get combinedReporterList() {
method type (line 39) | get type() {
method constructor (line 43) | constructor(settings, argv, addtOpts = {}) {
method runConcurrent (line 144) | async runConcurrent(testEnvArray, modules) {
method checkReporterDependencies (line 155) | checkReporterDependencies() {
method generateCombinedReport (line 171) | async generateCombinedReport() {
method isTestWorker (line 188) | isTestWorker() {
method closeOpenSessions (line 192) | closeOpenSessions() {
method registerUncaughtErr (line 215) | registerUncaughtErr(err) {
method run (line 222) | run(modules) {
FILE: lib/runner/test-runners/mocha/custom-runnable.js
function multiple (line 22) | function multiple(err) {
function done (line 37) | function done(err) {
FILE: lib/runner/test-runners/mocha/custom-runner.js
method runSuite (line 5) | async runSuite(suite, fn) {
method run (line 74) | run(fn) {
FILE: lib/runner/test-runners/mocha/extensions.js
method adaptRunnables (line 7) | static adaptRunnables(parent) {
method adaptHooks (line 34) | static adaptHooks(suite, hooks) {
method augmentTestSuite (line 53) | static augmentTestSuite({suite, runner, argv, settings, addtOpts}) {
FILE: lib/runner/test-source.js
class TestSource (line 9) | class TestSource {
method GroupNameDelimiter (line 10) | static get GroupNameDelimiter() {
method constructor (line 14) | constructor(settings, argv = {}) {
method getTestSourceForSingle (line 20) | getTestSourceForSingle(targetPath) {
method getRerunFailedFile (line 51) | getRerunFailedFile(minimal_report_file_path) {
method getTestSourceForRerunFailed (line 70) | getTestSourceForRerunFailed() {
method getSource (line 110) | getSource() {
method applySrcFilters (line 171) | applySrcFilters() {
method findGroupPath (line 199) | findGroupPath(groupName) {
method findGroupPathMultiple (line 220) | findGroupPathMultiple(groups) {
FILE: lib/settings/defaults.js
method beforeTestSuite (line 109) | beforeTestSuite(browser) {
method afterTestSuite (line 113) | afterTestSuite(browser) {
method beforeTestCase (line 117) | beforeTestCase(browser) {
method afterTestCase (line 121) | afterTestCase(browser) {
method onBrowserNavigate (line 125) | onBrowserNavigate(browser) {
method onBrowserQuit (line 129) | onBrowserQuit(browser) {
FILE: lib/settings/settings.js
class Settings (line 11) | class Settings {
method DEFAULT_ENV (line 13) | static get DEFAULT_ENV() {
method DEFAULTS (line 17) | static get DEFAULTS() {
method replaceEnvVariables (line 25) | static replaceEnvVariables(target) {
method getDefaults (line 43) | static getDefaults() {
method parse (line 56) | static parse(settings = {}, baseSettings = {}, argv = {}, testEnv = '') {
method fromClient (line 72) | static fromClient(userSettings = {}, argv = {}) {
method isNightwatchObject (line 79) | static isNightwatchObject(settings) {
method setDefaults (line 87) | static setDefaults(settings) {
method isUsingSeleniumServer (line 99) | static isUsingSeleniumServer(settings) {
method testWorkersEnabled (line 103) | get testWorkersEnabled() {
method constructor (line 126) | constructor(argv = {}, testEnv = '') {
method fromConfigFile (line 138) | fromConfigFile(baseSettings) {
method initSettingsObject (line 146) | initSettingsObject() {
method copyGenericProperties (line 157) | copyGenericProperties() {
method isSettingsDefined (line 173) | isSettingsDefined(settingName) {
method setWebdriverHttpOption (line 192) | setWebdriverHttpOption(newSetting, oldSetting, opts = {}) {
method isUsingSelenium (line 221) | isUsingSelenium() {
method isSeleniumServerManaged (line 227) | isSeleniumServerManaged() {
method setWebdriverSettings (line 234) | setWebdriverSettings() {
method setServerUrl (line 267) | setServerUrl() {
method mergeOntoExisting (line 277) | mergeOntoExisting(userSettings = {}) {
method adaptSettings (line 286) | adaptSettings() {
method setReporterOptions (line 305) | setReporterOptions() {
method setParallelMode (line 313) | setParallelMode() {
method setTestRunner (line 349) | setTestRunner() {
method setUnitTestsMode (line 362) | setUnitTestsMode() {
method inheritFromDefaultEnv (line 380) | inheritFromDefaultEnv() {
method inheritFromSuperEnv (line 400) | inheritFromSuperEnv(testEnvSettings) {
method persistGlobals (line 415) | persistGlobals(settings) {
method setScreenshotsOptions (line 422) | setScreenshotsOptions() {
method setCliOptions (line 435) | setCliOptions() {
method sortSettings (line 460) | sortSettings() {
method setBaseUrl (line 476) | setBaseUrl() {
method setColorOutput (line 487) | setColorOutput() {
method init (line 501) | init(userSettings = {}) {
FILE: lib/testsuite/context.js
class Context (line 8) | class Context extends EventEmitter {
method REPORT_KEY_SEPARATOR (line 9) | static get REPORT_KEY_SEPARATOR() {
method isTestHook (line 13) | get isTestHook() {
method constructor (line 17) | constructor({modulePath, settings, argv = {}, attributes = {}}) {
method setModulePath (line 37) | setModulePath(file) {
method loadTags (line 43) | loadTags({usingMocha = false} = {}) {
method init (line 71) | async init({usingMocha = false, suiteTitle = null, client = null} = {}) {
method testSuiteName (line 96) | get testSuiteName() {
method currentTest (line 100) | get currentTest() {
method contextBinding (line 104) | get contextBinding() {
method unitTestingMode (line 111) | get unitTestingMode() {
method unitTestsMode (line 119) | get unitTestsMode() {
method moduleName (line 123) | get moduleName() {
method module (line 127) | get module() {
method testsuite (line 131) | get testsuite() {
method tests (line 135) | get tests() {
method tests (line 139) | set tests(value) {
method skippedTests (line 143) | get skippedTests() {
method skippedTests (line 147) | set skippedTests(value) {
method allScreenedTests (line 151) | get allScreenedTests() {
method allScreenedTests (line 155) | set allScreenedTests(value) {
method hooks (line 159) | get hooks() {
method currentRunnable (line 163) | get currentRunnable() {
method queue (line 167) | get queue() {
method queueStarted (line 171) | get queueStarted() {
method retries (line 175) | get retries() {
method setReloadModuleCache (line 179) | setReloadModuleCache(val = true) {
method shouldReloadModuleCache (line 185) | shouldReloadModuleCache() {
method usingBddDescribe (line 189) | get usingBddDescribe() {
method getName (line 193) | getName() {
method getSuiteName (line 197) | getSuiteName() {
method setCurrentRunnable (line 201) | setCurrentRunnable(runnable) {
method createInterface (line 207) | createInterface(client) {
method loadModule (line 214) | async loadModule() {
method requireModule (line 233) | async requireModule(loadJsWithPlugins = false) {
method createTestSuite (line 276) | createTestSuite() {
method addTestSuiteMethod (line 287) | addTestSuiteMethod(testName, testFn, context) {
method addTestHook (line 299) | addTestHook(hookName, hookFn, context) {
method addTestCase (line 314) | addTestCase({testName, testFn, describeInstance, runOnly, skipTest}) {
method setDescribeContext (line 358) | setDescribeContext({describeTitle, describeInstance, runOnly}) {
method setTestcaseRetries (line 377) | setTestcaseRetries(n) {
method setSuiteRetries (line 381) | setSuiteRetries(n) {
method isES6Async (line 387) | isES6Async(testName) {
method addAttributes (line 391) | addAttributes(attributes = {}) {
method setAttribute (line 395) | setAttribute(name, value) {
method getAttribute (line 399) | getAttribute(name) {
method isDisabled (line 403) | isDisabled() {
method isUnitTest (line 407) | isUnitTest() {
method getSkipTestcasesOnFail (line 411) | getSkipTestcasesOnFail() {
method getEndSessionOnFail (line 415) | getEndSessionOnFail() {
method getNameAttr (line 419) | getNameAttr() {
method getTags (line 423) | getTags() {
method getDesiredCapabilities (line 427) | getDesiredCapabilities() {
method getHookFnArgs (line 441) | getHookFnArgs(done, api, expectedArgs) {
method extendContextWithApi (line 454) | extendContextWithApi(context, api) {
method invokeMethod (line 471) | invokeMethod(fnName, client, expectedArgs, done) {
method call (line 518) | call(fnName, ...args) {
method callAsync (line 545) | callAsync({fnName, api, expectedArgs = 2, done = function() {}, contex...
method hasHook (line 560) | hasHook(key) {
method getKey (line 564) | getKey(key) {
method getNextKey (line 568) | getNextKey() {
method reset (line 581) | reset() {
method setReportKey (line 590) | setReportKey(allModulePaths = []) {
method shouldCheckIfDirectory (line 626) | shouldCheckIfDirectory() {
method checkKeyForUniqueness (line 630) | checkKeyForUniqueness(allModulePaths, parentFolder) {
method getDiffFromSourceFolder (line 650) | getDiffFromSourceFolder(srcPathResolved, moduleParentFolder, source) {
method getUniqueModuleKey (line 672) | getUniqueModuleKey(modulePathsCopy, modulePathParts = null, moduleKey ...
FILE: lib/testsuite/globals.js
class GlobalsContext (line 9) | class GlobalsContext extends Context {
method throwError (line 10) | throwError(err) {
method isTestHook (line 18) | get isTestHook() {
method constructor (line 22) | constructor(settings, argv, currentEnv) {
method testsuite (line 29) | get testsuite() {
method init (line 33) | init(asyncLoading) {
method initModule (line 49) | initModule(loadFn, callback, asyncLoading) {
method loadModule (line 71) | async loadModule(isRetry = false) {
method loadModuleSync (line 90) | loadModuleSync(isRetry = false) {
method mergeGlobalsOntoSettings (line 119) | mergeGlobalsOntoSettings() {
method extendContextWithApi (line 134) | extendContextWithApi(context, api) {
method callAsync (line 148) | callAsync({fnName, api, expectedArgs = 2, isTestHook = false, isES6Asy...
method call (line 174) | call(fnName, ...args) {
method hasHook (line 184) | hasHook(key) {
method getKey (line 188) | getKey(key) {
method getHookFnArgs (line 199) | getHookFnArgs(done, api, expectedArgs) {
method setCurrentEnv (line 203) | setCurrentEnv() {
class Globals (line 216) | class Globals {
method constructor (line 217) | constructor(settings, argv, currentEnv = '') {
method globals (line 223) | get globals() {
method loadPlugins (line 227) | loadPlugins() {
method init (line 239) | init() {
method readExternal (line 245) | readExternal(asyncLoading) {
method mergeWithExisting (line 254) | mergeWithExisting() {
method setupGlobalHooks (line 272) | setupGlobalHooks() {
method runPluginHook (line 279) | async runPluginHook(hookName, args) {
method runGlobalHook (line 293) | async runGlobalHook(key, args = []) {
FILE: lib/testsuite/hooks.js
class TestHooks (line 3) | class TestHooks {
method TEST_HOOKS (line 4) | static get TEST_HOOKS () {
method constructor (line 15) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/_basehook.js
class BaseHook (line 4) | class BaseHook {
method beforeAll (line 5) | static get beforeAll() {
method beforeEach (line 9) | static get beforeEach() {
method beforeChildProcess (line 13) | static get beforeChildProcess() {
method afterAll (line 17) | static get afterAll() {
method afterEach (line 21) | static get afterEach() {
method afterChildProcess (line 25) | static get afterChildProcess() {
method skipTestcasesOnError (line 29) | get skipTestcasesOnError() {
method constructor (line 33) | constructor(hookName, context, addtOpts = {}) {
method isGlobal (line 40) | get isGlobal() {
method isUnitTest (line 44) | get isUnitTest() {
method run (line 54) | run(client = null, originalFn = null) {
method verifyMethod (line 139) | verifyMethod() {
method createCallbackWrapper (line 154) | createCallbackWrapper(resolve, reject, timeoutExpired) {
method onlyApiArgPassed (line 172) | onlyApiArgPassed(argsCount) {
method startQueueIfNeeded (line 176) | startQueueIfNeeded() {
method implicitlyCallDoneCallback (line 182) | implicitlyCallDoneCallback(doneFn) {
FILE: lib/testsuite/hooks/afterAll.js
class AfterAll (line 3) | class AfterAll extends BaseHook {
method constructor (line 4) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/afterChildProcess.js
class AfterChildProcess (line 3) | class AfterChildProcess extends BaseHook {
method constructor (line 4) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/afterEach.js
class AfterEach (line 3) | class AfterEach extends BaseHook {
method constructor (line 4) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/beforeAll.js
class BeforeAll (line 3) | class BeforeAll extends BaseHook {
method skipTestcasesOnError (line 4) | get skipTestcasesOnError() {
method constructor (line 8) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/beforeChildProcess.js
class BeforeChildProcess (line 3) | class BeforeChildProcess extends BaseHook {
method constructor (line 4) | constructor(context, addtOpts) {
FILE: lib/testsuite/hooks/beforeEach.js
class BeforeAll (line 3) | class BeforeAll extends BaseHook {
method skipTestcasesOnError (line 4) | get skipTestcasesOnError() {
method constructor (line 8) | constructor(context, addtOpts) {
FILE: lib/testsuite/index.js
class TestSuite (line 22) | class TestSuite {
method constructor (line 23) | constructor({modulePath, modules, settings, argv, usingMocha = false, ...
method api (line 43) | get api() {
method commandQueue (line 47) | get commandQueue() {
method reportPrefix (line 55) | get reportPrefix() {
method transport (line 59) | get transport() {
method skipTestcasesOnFail (line 63) | get skipTestcasesOnFail() {
method endSessionOnFail (line 80) | get endSessionOnFail() {
method isES6Async (line 86) | get isES6Async() {
method failFastMode (line 90) | get failFastMode() {
method isComponentTestingMode (line 94) | isComponentTestingMode() {
method isE2EPreviewMode (line 98) | isE2EPreviewMode() {
method shouldSkipTestsOnFail (line 102) | shouldSkipTestsOnFail() {
method initCommon (line 106) | async initCommon(opts = {}) {
method init (line 135) | async init(opts = {}) {
method setModulePath (line 143) | setModulePath(file) {
method validateNightwatchInspectorCriteria (line 148) | validateNightwatchInspectorCriteria() {
method initClient (line 156) | async initClient({initialize = true} = {}) {
method updateClient (line 170) | updateClient() {
method retrySuite (line 204) | async retrySuite() {
method createReporter (line 216) | createReporter() {
method createClient (line 244) | async createClient(client = null) {
method createContext (line 257) | async createContext({context = null, reloadModuleCache = false, suiteT...
method addPropertiesToGlobalScope (line 280) | addPropertiesToGlobalScope() {
method setUncaughtError (line 394) | setUncaughtError(err) {
method setReportPrefix (line 398) | setReportPrefix(data) {
method setRetries (line 419) | setRetries() {
method setSuiteName (line 432) | setSuiteName() {
method setupHooks (line 447) | setupHooks() {
method runHook (line 455) | runHook(hookName) {
method runGlobalHook (line 487) | runGlobalHook(hookName) {
method createSession (line 517) | createSession() {
method startTestSuite (line 534) | async startTestSuite() {
method runTestSuite (line 563) | runTestSuite() {
method onTestSectionFinished (line 631) | onTestSectionFinished() {
method onTestSuiteFinished (line 639) | onTestSuiteFinished(errorOrFailures = false) {
method onCommandFinished (line 679) | onCommandFinished({node, result}) {
method stopSession (line 684) | async stopSession(failures) {
method sendReportToParentWorker (line 695) | sendReportToParentWorker() {
method testSuiteFinished (line 712) | testSuiteFinished(failures) {
method sessionFinished (line 725) | async sessionFinished(reason) {
method terminate (line 735) | async terminate(reason = 'SIGINT', potentialError = null, endSession =...
method setReporterCurrentTest (line 788) | setReporterCurrentTest() {
method runNextTestCase (line 801) | runNextTestCase() {
method runCurrentTest (line 817) | runCurrentTest(testName) {
method testCaseFinished (line 881) | testCaseFinished() {
method shouldRetryTestCase (line 892) | shouldRetryTestCase() {
method retryCurrentTestCase (line 896) | retryCurrentTestCase() {
method isScreenshotEnabled (line 906) | isScreenshotEnabled() {
method shouldTakeScreenshotOnError (line 910) | shouldTakeScreenshotOnError() {
method shouldTakeScreenshotOnFailure (line 914) | shouldTakeScreenshotOnFailure() {
method getScreenshotFilenamePath (line 918) | getScreenshotFilenamePath() {
method takeScreenshot (line 925) | takeScreenshot() {
method takeSnapshot (line 958) | takeSnapshot(node) {
method shouldRetrySuite (line 987) | shouldRetrySuite(failures = false) {
method executeRunnable (line 995) | async executeRunnable(name, fn) {
method handleRunnable (line 1020) | async handleRunnable(name, fn) {
method print (line 1075) | print() {
method resetQueue (line 1115) | resetQueue() {
method emptyQueue (line 1125) | emptyQueue() {
method run (line 1139) | run() {
method isAssertionError (line 1157) | isAssertionError(err) {
FILE: lib/testsuite/interfaces/common.js
method TestHooks (line 4) | static get TestHooks() {
method DEFAULT_ATTRIBUTES (line 8) | static get DEFAULT_ATTRIBUTES() {
method constructor (line 20) | constructor(instance) {
method createInterface (line 26) | createInterface() {}
FILE: lib/testsuite/interfaces/describe.js
class DescribeInstance (line 11) | class DescribeInstance {
method constructor (line 12) | constructor({describeTitle, instance, client}) {
method name (line 22) | get name() {
method tags (line 26) | set tags(value) {
method tags (line 30) | get tags() {
method unitTest (line 34) | set unitTest(value) {
method unitTest (line 38) | get unitTest() {
method endSessionOnFail (line 42) | set endSessionOnFail(value) {
method endSessionOnFail (line 46) | get endSessionOnFail() {
method skipTestcasesOnFail (line 50) | set skipTestcasesOnFail(value) {
method skipTestcasesOnFail (line 54) | get skipTestcasesOnFail() {
method disabled (line 58) | set disabled(value) {
method disabled (line 62) | get disabled() {
method desiredCapabilities (line 66) | set desiredCapabilities(value) {
method desiredCapabilities (line 72) | get desiredCapabilities() {
method page (line 78) | get page() {
method globals (line 86) | get globals() {
method settings (line 90) | get settings() {
method argv (line 98) | get argv() {
method timeout (line 102) | timeout(value) {
method waitForTimeout (line 108) | waitForTimeout(value) {
method waitForRetryInterval (line 116) | waitForRetryInterval(value) {
method retryInterval (line 124) | retryInterval(value) {
method retries (line 128) | retries(n) {
method suiteRetries (line 132) | suiteRetries(n) {
method define (line 136) | define(name, value) {
class Describe (line 155) | class Describe extends Common {
method constructor (line 156) | constructor(instance, client = null) {
method createInstance (line 166) | createInstance(runOnly) {
method addHooks (line 187) | addHooks(context) {
method addRun (line 199) | addRun(context) {
method createTestsuite (line 205) | createTestsuite({title, describeFn, context, runOnly = false}) {
method addDescribe (line 217) | addDescribe(context) {
method addTest (line 248) | addTest(context) {
method shouldReloadModuleCache (line 270) | shouldReloadModuleCache() {
method createInterface (line 285) | createInterface(context) {
FILE: lib/testsuite/interfaces/exports.js
class Exports (line 4) | class Exports extends Common {
method module (line 5) | get module() {
method constructor (line 9) | constructor(instance) {
method includeTestcase (line 19) | includeTestcase(item) {
method reduceKeys (line 23) | reduceKeys(testFn) {
method addTestCase (line 34) | addTestCase(testName) {
method addTestHook (line 39) | addTestHook(key) {
method loadHooks (line 43) | loadHooks() {
method loadTests (line 48) | loadTests() {
method createInterface (line 53) | createInterface() {
method getAttribute (line 67) | getAttribute(attrName) {
method readAttributes (line 80) | readAttributes() {
FILE: lib/testsuite/nightwatch-inspector/index.js
method constructor (line 10) | constructor(client) {
method addExtensionInChromeOption (line 20) | addExtensionInChromeOption() {
method modifyCommandsResult (line 36) | modifyCommandsResult(result, executedCommand, commandList) {
method getNightwatchCommands (line 55) | getNightwatchCommands() {
method executeCommands (line 65) | async executeCommands(data) {
method playgroundWrapper (line 88) | async playgroundWrapper(data) {
FILE: lib/testsuite/nightwatch-inspector/websocket-server.js
method constructor (line 6) | constructor() {
method initSocket (line 10) | initSocket(cb) {
method startServer (line 18) | startServer(cb) {
method handleSocketError (line 37) | handleSocketError(e, cb) {
method nwsocket (line 48) | get nwsocket() {
method closeSocket (line 52) | closeSocket() {
FILE: lib/testsuite/repl.js
method constructor (line 6) | constructor(config) {
method introMessage (line 15) | static introMessage() {
method startServer (line 26) | startServer(context) {
method _eval (line 34) | _eval(cmd, _, filename, callback) {
method _handleResult (line 64) | async _handleResult(result, callback) {
method _outputPreview (line 114) | _outputPreview(cmd, callback) {
method onExit (line 133) | onExit(callback) {
FILE: lib/testsuite/retries.js
class SuiteRetries (line 1) | class SuiteRetries {
method constructor (line 2) | constructor({retries = 0, suiteRetries = 0}) {
method incrementTestRetriesCount (line 12) | incrementTestRetriesCount(testName) {
method incrementSuiteRetriesCount (line 17) | incrementSuiteRetriesCount() {
method shouldRetryTest (line 21) | shouldRetryTest(testName) {
method shouldRetrySuite (line 31) | shouldRetrySuite() {
FILE: lib/testsuite/runnable.js
class Runnable (line 1) | class Runnable {
method constructor (line 2) | constructor(name, runFn, opts = {}) {
method runFn (line 31) | get runFn() {
method currentPromise (line 35) | get currentPromise() {
method setQueue (line 48) | setQueue(queue) {
method setRunFn (line 59) | setRunFn(runFn) {
method createPromise (line 69) | createPromise() {
method abort (line 91) | abort(err) {
method setDoneCallback (line 105) | setDoneCallback(cb) {
method run (line 120) | run(queue = null) {
method queueInProgress (line 198) | queueInProgress() {
FILE: lib/testsuite/testcase.js
class UnitTest (line 4) | class UnitTest extends BaseHook {
method isGlobal (line 5) | get isGlobal() {
method isUnitTest (line 9) | get isUnitTest() {
method verifyMethod (line 13) | verifyMethod() {
class TestCase (line 18) | class TestCase {
method constructor (line 19) | constructor(testName, {context, settings, reporter, options = {}}) {
method print (line 32) | print() {
method run (line 49) | run(client = null) {
method runUnitTest (line 68) | runUnitTest() {
FILE: lib/transport/errors/index.js
method findErrorById (line 146) | findErrorById(statusCode) {
method getErrorObject (line 154) | getErrorObject(err) {
FILE: lib/transport/factory.js
method createSeleniumService (line 15) | static createSeleniumService(cliRunner) {
method usingSeleniumServer (line 28) | static usingSeleniumServer(settings) {
method adaptWebdriverSettings (line 45) | static adaptWebdriverSettings({settings, usingSeleniumServer = false}) {
method usingBrowserstackTurboScale (line 51) | static usingBrowserstackTurboScale(settings) {
method usingBrowserstack (line 55) | static usingBrowserstack(settings) {
method getBrowserName (line 59) | static getBrowserName(nightwatchInstance) {
method create (line 113) | static create(nightwatchInstance) {
method createWebdriver (line 123) | static createWebdriver(nightwatchInstance, {usingSeleniumServer, browser...
FILE: lib/transport/index.js
class Transport (line 7) | class Transport extends EventEmitter {
method DO_NOT_LOG_ERRORS (line 8) | static get DO_NOT_LOG_ERRORS() {
method Errors (line 16) | get Errors() {
method create (line 20) | static create(nightwatchInstance) {
method testSuiteFinished (line 30) | async testSuiteFinished(failures) {}
method sessionFinished (line 38) | async sessionFinished() {}
method isResultSuccess (line 40) | isResultSuccess() {
method resolveElement (line 51) | resolveElement(result, element, multipleElements) {
method getRetryableErrorMessages (line 85) | getRetryableErrorMessages() {
method createHttpRequest (line 105) | createHttpRequest(requestOptions) {
method runProtocolAction (line 109) | runProtocolAction(requestOptions) {
method sendHttpRequest (line 132) | sendHttpRequest(options) {
method handleProtocolError (line 147) | handleProtocolError(result, response = {}) {
method getElementNotFoundResult (line 182) | getElementNotFoundResult(result) {
method shouldRegisterError (line 197) | shouldRegisterError(result) {
FILE: lib/transport/selenium-webdriver/actions.js
class TransportActions (line 6) | class TransportActions {
method transport (line 7) | get transport() {
method actions (line 11) | get actions() {
method compatMode (line 15) | get compatMode() {
method constructor (line 19) | constructor(transport) {
method loadActions (line 27) | loadActions(methodMappings = this.MethodMappings.methods, target = thi...
method createAction (line 42) | createAction(name, mapping) {
method makeResult (line 84) | makeResult(result) {
method handleError (line 99) | handleError(err, commandName) {
FILE: lib/transport/selenium-webdriver/appium.js
class AppiumServer (line 6) | class AppiumServer extends AppiumBaseServer {
method createService (line 7) | static createService(settings) {
method defaultBrowser (line 20) | get defaultBrowser() {
method ServiceBuilder (line 24) | get ServiceBuilder() {
method defaultServerUrl (line 28) | get defaultServerUrl() {
method defaultPort (line 32) | get defaultPort() {
method defaultPathPrefix (line 36) | get defaultPathPrefix() {
method createSessionOptions (line 40) | createSessionOptions(argv) {
method createDriver (line 67) | createDriver({options}) {
FILE: lib/transport/selenium-webdriver/appiumBase.js
class AppiumBaseServer (line 8) | class AppiumBaseServer extends SeleniumServer {
method extractAppiumOptions (line 9) | extractAppiumOptions() {
method createAppiumDriver (line 26) | createAppiumDriver({options}) {
FILE: lib/transport/selenium-webdriver/browserstack/appAutomate.js
class AppAutomate (line 7) | class AppAutomate extends BrowserStack {
method ApiUrl (line 8) | get ApiUrl() {
method productNamespace (line 12) | get productNamespace() {
method createSessionOptions (line 16) | async createSessionOptions() {
method uploadAppToBrowserStack (line 27) | async uploadAppToBrowserStack(options) {
method createDriver (line 109) | createDriver({options}) {
FILE: lib/transport/selenium-webdriver/browserstack/automate.js
class Automate (line 4) | class Automate extends BrowserStack {
method ApiUrl (line 5) | get ApiUrl() {
method productNamespace (line 9) | get productNamespace() {
method createDriver (line 13) | createDriver({options = this.desiredCapabilities}) {
FILE: lib/transport/selenium-webdriver/browserstack/automateTurboScale.js
class AutomateTurboScale (line 4) | class AutomateTurboScale extends Automate {
method buildUrl (line 5) | get buildUrl() {
method ApiUrl (line 9) | get ApiUrl() {
method productNamespace (line 13) | get productNamespace() {
method buildsListingApiUrl (line 17) | get buildsListingApiUrl() {
method findBuildHashId (line 22) | findBuildHashId(buildsResponse) {
method sendReasonToBrowserstack (line 34) | async sendReasonToBrowserstack(isFailure = false, reason = '') {
FILE: lib/transport/selenium-webdriver/browserstack/browserstack.js
class Browserstack (line 7) | class Browserstack extends AppiumBaseServer {
method bStackOptions (line 8) | bStackOptions() {
method buildUrl (line 12) | get buildUrl() {
method buildsListingApiUrl (line 16) | get buildsListingApiUrl() {
method accessKey (line 21) | get accessKey() {
method username (line 25) | get username() {
method build (line 29) | get build() {
method local (line 33) | get local() {
method constructor (line 37) | constructor(nightwatchInstance, browserName) {
method findBuildHashId (line 52) | findBuildHashId(buildsResponse) {
method adaptSettings (line 63) | adaptSettings() {
method verifySettings (line 95) | verifySettings() {
method createSession (line 113) | createSession({argv, moduleKey}) {
method getBuildId (line 120) | async getBuildId() {
method sendReasonToBrowserstack (line 152) | async sendReasonToBrowserstack(isFailure = false, reason = '') {
method sessionFinished (line 187) | async sessionFinished(reason, err) {
method testSuiteFinished (line 192) | async testSuiteFinished(err) {
FILE: lib/transport/selenium-webdriver/cdp.js
class Cdp (line 1) | class Cdp {
method getConnection (line 2) | async getConnection(driver, reset = false) {
method resetConnection (line 10) | resetConnection() {
method networkMocks (line 15) | get networkMocks() {
method addNetworkMock (line 23) | addNetworkMock(url, response) {
FILE: lib/transport/selenium-webdriver/chrome.js
method ServiceBuilder (line 5) | get ServiceBuilder() {
method setBuilderOptions (line 9) | setBuilderOptions({builder, options}) {
FILE: lib/transport/selenium-webdriver/edge.js
method ServiceBuilder (line 5) | get ServiceBuilder() {
method setBuilderOptions (line 9) | setBuilderOptions({builder, options}) {
FILE: lib/transport/selenium-webdriver/firefox.js
method ServiceBuilder (line 5) | get ServiceBuilder() {
method setBuilderOptions (line 9) | setBuilderOptions({builder, options}) {
FILE: lib/transport/selenium-webdriver/httpclient.js
method constructor (line 8) | constructor(serverUrl, opt_agent, opt_proxy) {
method send (line 41) | send(httpRequest) {
FILE: lib/transport/selenium-webdriver/index.js
class Transport (line 18) | class Transport extends BaseTransport {
method setBuilderOptions (line 23) | static setBuilderOptions({builder, options}) {
method driver (line 51) | static get driver() {
method driver (line 55) | static set driver(value) {
method driverService (line 59) | static get driverService() {
method driverService (line 63) | static set driverService(value) {
method ServiceBuilder (line 71) | get ServiceBuilder() {
method defaultPort (line 75) | get defaultPort() {
method Actions (line 79) | get Actions() {
method reporter (line 83) | get reporter() {
method api (line 87) | get api() {
method settings (line 91) | get settings() {
method desiredCapabilities (line 95) | get desiredCapabilities() {
method defaultPathPrefix (line 99) | get defaultPathPrefix() {
method outputEnabled (line 103) | get outputEnabled() {
method usingSeleniumServer (line 107) | get usingSeleniumServer() {
method shouldStartDriverService (line 111) | get shouldStartDriverService() {
method serviceName (line 115) | get serviceName() {
method elementKey (line 119) | get elementKey() {
method initialCapabilities (line 123) | get initialCapabilities() {
method parallelMode (line 127) | get parallelMode() {
method constructor (line 131) | constructor(nightwatchInstance, {isSelenium = false, browserName} = {}) {
method setBuilderOptions (line 149) | setBuilderOptions({options, builder}) {
method createActions (line 153) | createActions() {
method createHttpClient (line 158) | createHttpClient() {
method getServerUrl (line 163) | getServerUrl() {
method closeDriver (line 174) | async closeDriver() {
method sessionFinished (line 189) | async sessionFinished(reason) {
method createDriverService (line 195) | async createDriverService({options, moduleKey, reuseBrowser = false}) {
method shouldReuseDriverService (line 212) | shouldReuseDriverService(reuseBrowser) {
method getDriver (line 219) | async getDriver({options, reuseBrowser = false}) {
method shouldReuseDriver (line 231) | async shouldReuseDriver(reuseBrowser) {
method createSessionBuilder (line 248) | createSessionBuilder(options) {
method createSessionOptions (line 257) | createSessionOptions(argv) {
method createDriver (line 261) | createDriver({options}) {
method createSession (line 269) | async createSession({argv, moduleKey, reuseBrowser = false}) {
method showConnectInfo (line 316) | async showConnectInfo({startTime, port, host, start_process, sessionIn...
method showConnectSpinner (line 334) | showConnectSpinner(msg, method = 'info') {
method getElementId (line 349) | getElementId(resultValue) {
method toElement (line 353) | toElement(resultValue) {
method mapWebElementIds (line 357) | mapWebElementIds(value) {
method executeProtocolAction (line 376) | executeProtocolAction(protocolAction, executeArgs) {
method handleErrorResponse (line 397) | handleErrorResponse(result) {
method registerLastError (line 407) | registerLastError(err, retryCount = 0) {
method getErrorMessage (line 412) | getErrorMessage(result) {
method handleConnectError (line 420) | handleConnectError(err, host, port) {
method isResultSuccess (line 452) | isResultSuccess(result = {}) {
method getOutputFilePath (line 460) | getOutputFilePath() {
method getErrorResponse (line 464) | getErrorResponse(result) {
method staleElementReference (line 468) | staleElementReference(result) {
method elementClickInterceptedError (line 472) | elementClickInterceptedError(result) {
method invalidElementStateError (line 476) | invalidElementStateError(result) {
method elementNotInteractableError (line 480) | elementNotInteractableError(result) {
method invalidWindowReference (line 484) | invalidWindowReference(result) {
method invalidSessionError (line 488) | invalidSessionError(result) {
method isRetryableElementError (line 492) | isRetryableElementError(result) {
FILE: lib/transport/selenium-webdriver/method-mappings.js
method driver (line 10) | get driver() {
method settings (line 14) | get settings() {
method getWebElement (line 18) | getWebElement(webElementOrString) {
method runScriptForElement (line 34) | async runScriptForElement(scriptFn, webElementOrId) {
method getElementByJs (line 42) | async getElementByJs(scriptFn, webElementOrId) {
method constructor (line 85) | constructor(transport) {
method executeFn (line 89) | executeFn(fn, name, args) {
method methods (line 97) | get methods() {
FILE: lib/transport/selenium-webdriver/options.js
method initialCapabilities (line 5) | get initialCapabilities() {
method isChrome (line 9) | get isChrome() {
method isSafari (line 13) | get isSafari() {
method isEdge (line 17) | get isEdge() {
method isFirefox (line 21) | get isFirefox() {
method constructor (line 25) | constructor({settings, browserName}) {
method createDesired (line 36) | createDesired() {
method createInitialCapabilities (line 58) | createInitialCapabilities() {
method alreadyDefinedAs (line 66) | alreadyDefinedAs(OptionsClass) {
method create (line 70) | create(argv = {}) {
method createChromeOptions (line 113) | createChromeOptions() {
method createIeOptions (line 146) | createIeOptions() {
method createEdgeOptions (line 167) | createEdgeOptions() {
method createFirefoxOptions (line 195) | createFirefoxOptions() {
method createSafariOptions (line 216) | createSafariOptions() {
method usingSeleniumServer (line 228) | usingSeleniumServer() {
method shouldSetupWebdriver (line 232) | shouldSetupWebdriver() {
method getChromedriverPath (line 236) | getChromedriverPath() {
method getGeckodriverPath (line 244) | getGeckodriverPath() {
method getAppiumPath (line 252) | getAppiumPath() {
method updateWebdriverPath (line 256) | updateWebdriverPath() {
method hasDevtoolsFlag (line 303) | hasDevtoolsFlag(options) {
method addDevtoolsOption (line 307) | addDevtoolsOption({options}) {
method addHeadlessOption (line 335) | addHeadlessOption({options}) {
method addWindowSizeOption (line 349) | addWindowSizeOption({options}) {
method addProxyOption (line 357) | addProxyOption({options}) {
FILE: lib/transport/selenium-webdriver/safari.js
method ServiceBuilder (line 6) | get ServiceBuilder() {
method defaultServerUrl (line 10) | get defaultServerUrl() {
method createDriver (line 14) | createDriver({options}) {
class SafariDriver (line 46) | class SafariDriver extends WebDriver {
method createSession (line 47) | static createSession(options, service, serverUrl) {
method setFileDetector (line 70) | setFileDetector() {}
FILE: lib/transport/selenium-webdriver/selenium.js
method createService (line 8) | static createService(settings) {
method defaultBrowser (line 21) | get defaultBrowser() {
method ServiceBuilder (line 25) | get ServiceBuilder() {
method defaultServerUrl (line 29) | get defaultServerUrl() {
method defaultPathPrefix (line 33) | get defaultPathPrefix() {
method constructor (line 37) | constructor(nightwatchInstance, browserName) {
method closeDriver (line 46) | async closeDriver() {}
method sessionFinished (line 48) | async sessionFinished(reason) {
method setBuilderOptions (line 68) | setBuilderOptions({builder, options}) {
FILE: lib/transport/selenium-webdriver/service-builders/appium.js
class AppiumService (line 5) | class AppiumService extends DriverService {
method constructor (line 6) | constructor(server_path, opt_options) {
class AppiumServiceBuilder (line 33) | class AppiumServiceBuilder extends BaseService {
method serviceName (line 34) | static get serviceName() {
method defaultPort (line 38) | static get defaultPort() {
method npmPackageName (line 42) | get npmPackageName() {
method outputFile (line 46) | get outputFile() {
method defaultPort (line 50) | get defaultPort() {
method serviceName (line 54) | get serviceName() {
method downloadMessage (line 58) | get downloadMessage() {
method createService (line 67) | async createService(opts = {}) {
FILE: lib/transport/selenium-webdriver/service-builders/base-service.js
class BaseService (line 7) | class BaseService {
method outputFile (line 8) | get outputFile() {
method serviceName (line 12) | get serviceName() {
method serviceDownloadUrl (line 16) | get serviceDownloadUrl() {
method requiresDriverBinary (line 20) | get requiresDriverBinary() {
method DEFAULT_HOST (line 24) | static get DEFAULT_HOST() {
method npmPackageName (line 28) | get npmPackageName() {
method downloadMessage (line 32) | get downloadMessage() {
method errorMessages (line 37) | get errorMessages() {
method errorOutput (line 53) | get errorOutput() {
method defaultPort (line 65) | get defaultPort() {
method constructor (line 69) | constructor(settings) {
method setCliArgs (line 97) | setCliArgs(args) {
method createSinkProcess (line 110) | createSinkProcess() {
method createErrorMessage (line 131) | createErrorMessage(code) {
method onExit (line 139) | onExit(code) {
method onError (line 160) | onError(err) {
method onClose (line 176) | onClose() {
method createError (line 180) | createError(message, code = 1) {
method getStartupErrorMessage (line 192) | getStartupErrorMessage(message) {
method onStdout (line 210) | onStdout(data) {
method onStderr (line 214) | onStderr(data) {
method needsSinkProcess (line 219) | needsSinkProcess() {
method hasSinkSupport (line 223) | hasSinkSupport() {
method createService (line 231) | async createService(options) {
method init (line 264) | async init(options = {}) {
method getSettingsFormatted (line 284) | getSettingsFormatted() {
method stop (line 293) | async stop() {
method setOutputFile (line 316) | setOutputFile(fileName) {
method getSeleniumLogPath (line 322) | getSeleniumLogPath() {
method getLogPath (line 326) | getLogPath() {
method getSeleniumOutputFilePath (line 335) | getSeleniumOutputFilePath() {
method getOutputFilePath (line 344) | getOutputFilePath() {
method writeLogFile (line 358) | async writeLogFile() {
FILE: lib/transport/selenium-webdriver/service-builders/chrome.js
class ChromeServiceBuilder (line 4) | class ChromeServiceBuilder extends BaseService {
method serviceName (line 5) | static get serviceName() {
method defaultPort (line 9) | static get defaultPort() {
method npmPackageName (line 13) | get npmPackageName() {
method outputFile (line 17) | get outputFile() {
method serviceName (line 21) | get serviceName() {
method serviceDownloadUrl (line 25) | get serviceDownloadUrl() {
method createService (line 33) | async createService(options) {
method requiresDriverBinary (line 62) | get requiresDriverBinary() {
FILE: lib/transport/selenium-webdriver/service-builders/edge.js
class EdgeServiceBuilder (line 4) | class EdgeServiceBuilder extends BaseService {
method serviceName (line 5) | static get serviceName() {
method defaultPort (line 9) | static get defaultPort() {
method requiresDriverBinary (line 13) | get requiresDriverBinary() {
method outputFile (line 17) | get outputFile() {
method serviceName (line 21) | get serviceName() {
method serviceDownloadUrl (line 25) | get serviceDownloadUrl() {
method createService (line 33) | async createService(options) {
FILE: lib/transport/selenium-webdriver/service-builders/firefox.js
class FirefoxServiceBuilder (line 4) | class FirefoxServiceBuilder extends BaseService {
method serviceName (line 5) | static get serviceName() {
method defaultPort (line 9) | static get defaultPort() {
method npmPackageName (line 13) | get npmPackageName() {
method outputFile (line 17) | get outputFile() {
method serviceName (line 21) | get serviceName() {
method serviceDownloadUrl (line 25) | get serviceDownloadUrl() {
method createService (line 33) | async createService(options) {
method requiresDriverBinary (line 54) | get requiresDriverBinary() {
FILE: lib/transport/selenium-webdriver/service-builders/safari.js
constant OPTIONS_CAPABILITY_KEY (line 5) | const OPTIONS_CAPABILITY_KEY = 'safari.options';
constant TECHNOLOGY_PREVIEW_OPTIONS_KEY (line 6) | const TECHNOLOGY_PREVIEW_OPTIONS_KEY = 'technologyPreview';
constant SAFARIDRIVER_TECHNOLOGY_PREVIEW_EXE (line 7) | const SAFARIDRIVER_TECHNOLOGY_PREVIEW_EXE = '/Applications/Safari Techno...
function useTechnologyPreview (line 9) | function useTechnologyPreview(o) {
class SafariServiceBuilder (line 23) | class SafariServiceBuilder extends BaseService {
method serviceName (line 24) | static get serviceName() {
method requiresDriverBinary (line 28) | get requiresDriverBinary() {
method outputFile (line 32) | get outputFile() {
method defaultPort (line 40) | get defaultPort() {
method serviceName (line 44) | get serviceName() {
method createService (line 52) | async createService(options) {
FILE: lib/transport/selenium-webdriver/service-builders/selenium.js
class SeleniumServer4 (line 6) | class SeleniumServer4 extends DriverService {
method constructor (line 7) | constructor(jar, opt_options) {
class SeleniumServiceBuilder (line 35) | class SeleniumServiceBuilder extends BaseService {
method serviceName (line 36) | static get serviceName() {
method defaultPort (line 40) | static get defaultPort() {
method npmPackageName (line 44) | get npmPackageName() {
method outputFile (line 48) | get outputFile() {
method defaultPort (line 52) | get defaultPort() {
method serviceName (line 56) | get serviceName() {
method serviceDownloadUrl (line 60) | get serviceDownloadUrl() {
method downloadMessage (line 64) | get downloadMessage() {
method setCliArgs (line 69) | setCliArgs() {
method usingSelenium4 (line 108) | usingSelenium4() {
method createService (line 118) | async createService(opts = {}) {
FILE: lib/transport/selenium-webdriver/session.js
method WEB_ELEMENT_ID (line 2) | static get WEB_ELEMENT_ID () {
method serializeCapabilities (line 6) | static serializeCapabilities(caps) {
method constructor (line 18) | constructor(driver) {
method exported (line 22) | async exported() {
FILE: lib/utils/analytics.js
constant GA_SERVER_URL (line 15) | const GA_SERVER_URL = 'https://www.google-analytics.com';
constant GA_SERVER_PORT (line 16) | const GA_SERVER_PORT = '443';
constant GA_API_KEY (line 17) | const GA_API_KEY = 'XuPojOTwQ6yTO758EV4hBg';
constant GA_TRACKING_ID (line 18) | const GA_TRACKING_ID = 'G-DEKPKZSLXS';
constant RESERVED_EVENT_NAMES (line 26) | const RESERVED_EVENT_NAMES = ['ad_activeview', 'ad_click', 'ad_exposure'...
constant ALLOWED_ERRORS (line 31) | const ALLOWED_ERRORS = ['Error', 'SyntaxError', 'TypeError', 'ReferenceE...
constant RESERVED_EVENT_PARAMETERS (line 34) | const RESERVED_EVENT_PARAMETERS = ['firebase_conversion'];
constant MAX_PARAMETERS_LENGTH (line 36) | const MAX_PARAMETERS_LENGTH = 40;
constant SYSTEM_LANGUAGE (line 38) | const SYSTEM_LANGUAGE = getLanguage();
class AnalyticsCollector (line 43) | class AnalyticsCollector {
method constructor (line 44) | constructor() {
method initialize (line 58) | initialize() {
method updateSettings (line 77) | updateSettings(settings) {
method updateLogger (line 89) | updateLogger(logger) {
method collectEvent (line 93) | async collectEvent(name, parameters = {}) {
method collectErrorEvent (line 117) | async collectErrorEvent(error, isUncaught = false) {
method __flush (line 152) | async __flush() {
method __addToQueue (line 190) | async __addToQueue(eventType, parameters) {
method __send (line 206) | async __send(data) {
method __getGoogleAnalyticsPath (line 255) | __getGoogleAnalyticsPath() {
method __logAnalyticsEvents (line 262) | async __logAnalyticsEvents(data) {
method __getLogFileLocation (line 288) | __getLogFileLocation() {
method __validateEvent (line 294) | __validateEvent(name, parameters) {
function getLanguage (line 325) | function getLanguage() {
function getWindowsLanguageCode (line 336) | function getWindowsLanguageCode() {
function buildUserAgentString (line 353) | function buildUserAgentString() {
FILE: lib/utils/beautifyStackTrace.js
function beautifyStackTrace (line 12) | function beautifyStackTrace(err, errStackPassed = false, modulepath, cli...
function formatStackTrace (line 58) | function formatStackTrace(errorLinesofFile, parsedStack) {
FILE: lib/utils/browsername.js
method CHROME (line 2) | get CHROME() {
method FIREFOX (line 6) | get FIREFOX() {
method SAFARI (line 10) | get SAFARI() {
method EDGE (line 14) | get EDGE() {
method INTERNET_EXPLORER (line 18) | get INTERNET_EXPLORER() {
method OPERA (line 22) | get OPERA() {
FILE: lib/utils/chalkColors.js
class ChalkColors (line 3) | class ChalkColors {
method constructor (line 4) | constructor() {
method loadCustomColors (line 15) | loadCustomColors() {
method colors (line 32) | get colors() {
method colorsEnabled (line 36) | get colorsEnabled() {
method disable (line 40) | disable() {
method enable (line 45) | enable() {
method reset (line 49) | reset() {
FILE: lib/utils/debuggability.js
class Debuggability (line 1) | class Debuggability {
method stepOverAndPause (line 2) | static get stepOverAndPause() {
method stepOverAndPause (line 6) | static set stepOverAndPause(value) {
method reset (line 10) | static reset() {
method debugMode (line 14) | static get debugMode() {
method debugMode (line 18) | static set debugMode(value) {
FILE: lib/utils/index.js
constant VERSION (line 21) | const VERSION = require('./version.js');
class Utils (line 39) | class Utils {
method tsFileExt (line 40) | static get tsFileExt() {
method jsFileExt (line 44) | static get jsFileExt() {
method isObject (line 48) | static isObject(obj) {
method isFunction (line 52) | static isFunction(fn) {
method isBoolean (line 56) | static isBoolean(value) {
method isNumber (line 60) | static isNumber(value) {
method isString (line 64) | static isString(value) {
method isUndefined (line 68) | static isUndefined(value) {
method isDefined (line 72) | static isDefined(value) {
method isES6AsyncFn (line 76) | static isES6AsyncFn(fn) {
method enforceType (line 80) | static enforceType(value, type) {
method convertBoolean (line 98) | static convertBoolean(value) {
method symbols (line 106) | static get symbols() {
method convertToElementSelector (line 125) | static convertToElementSelector(definition) {
method isElementGlobal (line 131) | static isElementGlobal(selector) {
method setElementSelectorProps (line 140) | static setElementSelectorProps(definition, props = {}) {
method formatElapsedTime (line 153) | static formatElapsedTime(timeMs, includeMs = false) {
method makeFnAsync (line 171) | static makeFnAsync(asyncArgCount, fn, context) {
method makePromise (line 184) | static makePromise(handler, context, args) {
method checkFunction (line 193) | static checkFunction(name, parent) {
method getTestSuiteName (line 197) | static getTestSuiteName(moduleName) {
method format (line 224) | static format(message, selector, timeMS) {
method getModuleKey (line 243) | static getModuleKey(filePath, srcFolders, fullPaths) {
method getOriginalStackTrace (line 268) | static getOriginalStackTrace(commandFn) {
method dirExistsSync (line 283) | static dirExistsSync(path) {
method fileExistsSync (line 291) | static fileExistsSync(path) {
method fileExists (line 299) | static fileExists(path) {
method isTsFile (line 309) | static isTsFile(fileName){
method validExtensions (line 313) | static get validExtensions() {
method isFileNameValid (line 326) | static isFileNameValid(fileName) {
method checkPath (line 330) | static checkPath(source, originalErr = null, followSymlinks = true) {
method isFolder (line 350) | static isFolder(source) {
method readDir (line 358) | static readDir(source) {
method readFolderRecursively (line 378) | static readFolderRecursively(sourcePath, namespace = [], loadFn, readS...
method getPluginPath (line 411) | static getPluginPath(pluginName) {
method singleSourceFile (line 417) | static singleSourceFile(argv = {}) {
method getConfigFolder (line 427) | static getConfigFolder(argv) {
method flattenArrayDeep (line 442) | static flattenArrayDeep(arr, maxDepth = 4, includeEmpty = false) {
method stripControlChars (line 480) | static stripControlChars(input) {
method relativeUrl (line 488) | static relativeUrl(url) {
method uriJoin (line 492) | static uriJoin(baseUrl, uriPath) {
method replaceParams (line 506) | static replaceParams(url, params = {}) {
method createFolder (line 514) | static createFolder(dirPath) {
method writeToFile (line 531) | static writeToFile(filePath, data, encoding = null) {
method containsMultiple (line 551) | static containsMultiple(arrayOrString, valueToFind, separator = ',') {
method shouldReplaceStack (line 567) | static shouldReplaceStack(err) {
method findTSConfigFile (line 571) | static findTSConfigFile(existingTSConfig) {
method loadTSNode (line 589) | static loadTSNode(projectTsFile) {
method isSafari (line 616) | static isSafari(desiredCapabilities = {}) {
method isChrome (line 626) | static isChrome(desiredCapabilities = {}) {
method isLocalhost (line 636) | static isLocalhost(webdriver = {}) {
method setFunctionName (line 642) | static setFunctionName(fn, name) {
method stringifyObject (line 653) | static stringifyObject(objects) {
method mkpath (line 662) | static mkpath(dirpath, mode, callback) {
FILE: lib/utils/locatestrategy.js
class LocateStrategy (line 3) | class LocateStrategy {
method Strategies (line 4) | static get Strategies() {
method isValid (line 22) | static isValid(strategy) {
method getList (line 28) | static getList() {
method XPATH (line 32) | static get XPATH() {
method CSS_SELECTOR (line 36) | static get CSS_SELECTOR() {
method getDefault (line 40) | static getDefault() {
method Recursion (line 44) | static get Recursion() {
FILE: lib/utils/logger/index.js
function pad (line 27) | function pad(n) {
function timestamp (line 34) | function timestamp(d = new Date(), format) {
function inspectObject (line 48) | function inspectObject(obj) {
function logObject (line 58) | function logObject(obj) {
function logTimestamp (line 63) | function logTimestamp(d) {
function logMessage (line 71) | function logMessage(type, message, args, alwaysShow) {
function findSuggestion (line 151) | function findSuggestion({message} = {}) {
function logRequest (line 166) | function logRequest(message, params) {
function logError (line 181) | function logError(severity, errOrMessage,
Condensed preview — 1247 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,232K chars).
[
{
"path": ".eslintignore",
"chars": 93,
"preview": "node_modules\npackage.json\n*.json\nlib/utils/requireModule.js\nlib/reporter/reporters/html\ndist\n"
},
{
"path": ".eslintrc",
"chars": 2634,
"preview": "{\n \"root\": true,\n \"extends\": [\n \"eslint:recommended\"\n ],\n \"parserOptions\": {\n \"ecmaVersion\": 13,\n \"sourceTy"
},
{
"path": ".github/FUNDING.yml",
"chars": 28,
"preview": "open_collective: nightwatch\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.yml",
"chars": 4431,
"preview": "name: \"Bug Report\"\ndescription: \"File a bug report to help us improve Nightwatch.\"\nbody:\n - type: \"markdown\"\n attrib"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 556,
"preview": "blank_issues_enabled: true\ncontact_links:\n - name: Ask a question\n url: https://github.com/nightwatchjs/nightwatch/d"
},
{
"path": ".github/ISSUE_TEMPLATE/feature-request.yml",
"chars": 1199,
"preview": "name: \"Feature Request\"\ndescription: \"Request a feature or enhancement for Nightwatch\"\nlabels: [\"enhancement\"]\nbody:\n -"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1456,
"preview": "Thanks in advance for your contribution. Please follow the below steps in submitting a pull request, as it will help us "
},
{
"path": ".github/label-commenter-config.yml",
"chars": 1252,
"preview": " # Configuration for Label Commenter - https://github.com/peaceiris/actions-label-commenter\nlabels:\n - name: needs-tri"
},
{
"path": ".github/stale.yml",
"chars": 812,
"preview": "# Number of days of inactivity before an issue becomes stale\ndaysUntilStale: 90\n# Number of days of inactivity before a "
},
{
"path": ".github/workflows/build-node.yaml",
"chars": 1220,
"preview": "# This workflow will do a clean install of node dependencies, build the source code and run tests across different versi"
},
{
"path": ".github/workflows/component-tests.yaml",
"chars": 574,
"preview": "name: component-tests\n\non:\n push:\n branches: [ main]\n pull_request:\n branches: [ main]\n\njobs:\n linux:\n\n runs"
},
{
"path": ".github/workflows/coverage.yml",
"chars": 1176,
"preview": "# This workflow will do a clean install of node dependencies, build the source code and run tests across different versi"
},
{
"path": ".github/workflows/label-commenter.yml",
"chars": 368,
"preview": "# Configuration for Label Commenter - https://github.com/peaceiris/actions-label-commenter\nname: Label Commenter\n\non:\n "
},
{
"path": ".github/workflows/missing-types-comment.yml",
"chars": 3864,
"preview": "name: Add comment for missing types\n\non:\n workflow_run:\n workflows: [\"Check missing types\"]\n types:\n - compl"
},
{
"path": ".github/workflows/missing-types.yml",
"chars": 681,
"preview": "name: Check missing types\n\non: pull_request\n\njobs:\n detect-modified-files:\n runs-on: ubuntu-latest\n steps:\n "
},
{
"path": ".github/workflows/nightly.yml",
"chars": 1067,
"preview": "name: Nightly\n\non:\n workflow_dispatch:\n inputs:\n version:\n description: Nightly version\n required"
},
{
"path": ".github/workflows/publish.yml",
"chars": 567,
"preview": "name: Publish to NPM\non:\n push:\n tags:\n - vv* # to enable this action, change this tag back to v*\njobs:\n publi"
},
{
"path": ".github/workflows/type-declaration-tests.yml",
"chars": 683,
"preview": "name: Type Declaration Tests\n\non:\n push:\n branches: [main, feat/types-test]\n pull_request:\n branches: [main]\n\njo"
},
{
"path": ".gitignore",
"chars": 389,
"preview": ".project\n.DS_Store\n*.vim\n*.idea\n*.vscode\n*.log\n*.env\n/nightwatch.json\n/nightwatch.conf.js\nnode_modules\ndist\nnpm-debug.lo"
},
{
"path": ".husky/pre-commit",
"chars": 58,
"preview": "#!/bin/sh\n. \"$(dirname \"$0\")/_/husky.sh\"\n\nnpx lint-staged\n"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3859,
"preview": "# Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, we as contributors and"
},
{
"path": "CONTRIBUTING.md",
"chars": 3728,
"preview": "# Contributing to Nightwatch\n\nContributions to Nightwatch are always welcome but please try to follow these guidelines w"
},
{
"path": "LICENSE.md",
"chars": 1213,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2014-2021, Pine View Software AS. https://pineview.io \nCo"
},
{
"path": "README.md",
"chars": 7423,
"preview": "# Nightwatch.js\n\n[](https://www.npmjs.com/package/nightwatch)\n[![Node"
},
{
"path": "api/README.md",
"chars": 2383,
"preview": "# Nightwatch API Commands\nPublic commands api exported by Nightwatch in order to be extended upon from outside.\n\n**Examp"
},
{
"path": "api/index.js",
"chars": 936,
"preview": "const path = require('path');\nconst exportedCommands = [\n 'element-commands/findElement.js',\n 'element-commands/findEl"
},
{
"path": "bin/.gitignore",
"chars": 84,
"preview": "selenium-server-standalone-*\nchromedriver\nchromedriver-*\nphantomjs\nIEDriverServer_*\n"
},
{
"path": "bin/nightwatch",
"chars": 531,
"preview": "#!/usr/bin/env node\n\nconst semver = require('semver');\nconst {Logger} = require('../lib/utils');\nconst requiredVersion ="
},
{
"path": "bin/runner.js",
"chars": 959,
"preview": "/**\n * Module dependencies\n */\nconst Nightwatch = require('../lib/index.js');\nconst {Logger, shouldReplaceStack, alwaysD"
},
{
"path": "bin/show_survey.js",
"chars": 272,
"preview": "#!/usr/bin/env node\n\n// eslint-disable-next-line\nconsole.log('\\t 👋 Hey there! Thanks for installing Nightwatch. \\n\\n\\tP"
},
{
"path": "codecov.yml",
"chars": 222,
"preview": "codecov:\n require_ci_to_pass: yes\n\ncoverage:\n precision: 2\n round: down\n range: \"70...100\"\n\nparsers:\n gcov:\n bra"
},
{
"path": "examples/.gitignore",
"chars": 16,
"preview": "reports\nscreens\n"
},
{
"path": "examples/cucumber-js/README.md",
"chars": 7670,
"preview": "# Using Cucumber.js with Nightwatch 2\n\nNightwatch 2 brings integrated support for using [Cucumber.js](https://cucumber.i"
},
{
"path": "examples/cucumber-js/features/nightwatch.feature",
"chars": 452,
"preview": "Feature: Google Search\nBackground: Background name\n Given I open the Rijksmuseum page\n And I dismiss the cookie dialog"
},
{
"path": "examples/cucumber-js/features/step_definitions/nightwatch.js",
"chars": 1132,
"preview": "const {Given, Then, When, Before} = require('@cucumber/cucumber');\n\nGiven(/^I open the Rijksmuseum page$/, function() {\n"
},
{
"path": "examples/custom-assertions/testCustomAssertion.js",
"chars": 1166,
"preview": "const util = require('util');\n\nexports.assertion = function(selector, attribute, expected, msg) {\n let DEFAULT_MSG = 'T"
},
{
"path": "examples/custom-commands/angular/getElementsInList.js",
"chars": 590,
"preview": "module.exports = class AngularCommand {\n async command(listName, cb = function(r) {return r}) {\n return this.api.exe"
},
{
"path": "examples/custom-commands/strictClick.js",
"chars": 129,
"preview": "module.exports = {\n command: function(selector){\n return this.waitForElementVisible(selector)\n .click(selector)"
},
{
"path": "examples/globals.json",
"chars": 84,
"preview": "{\n \"default\" : {\n \"myGlobal\" : 1\n },\n \"test_env\" : {\n \"myGlobal\" : 2\n }\n}\n"
},
{
"path": "examples/globalsModule.js",
"chars": 2063,
"preview": "module.exports = {\n // this controls whether to abort the test execution when an assertion failed and skip the rest\n /"
},
{
"path": "examples/pages/google/consent.js",
"chars": 1357,
"preview": "class ConsentCommand {\n turnOffSearchCustomization() {\n this.page.section.customizeSearch.click('@turnOffButton');\n\n"
},
{
"path": "examples/pages/google/search.js",
"chars": 668,
"preview": "const searchCommands = {\n submit() {\n this.waitForElementVisible('@submitButton', 1000)\n .click('@submitButton'"
},
{
"path": "examples/pages/google/searchResults.js",
"chars": 1317,
"preview": "const util = require('util');\n\n// starting xpath with './/' tells browser to begin search from the current element,\n// w"
},
{
"path": "examples/pages/nightwatchFeatures.js",
"chars": 618,
"preview": "const featuresCommands = {\n getFeatureCount: function(callback) {\n this.api.elements(null, this.elements.features, f"
},
{
"path": "examples/test-app/globals.js",
"chars": 628,
"preview": "const waitOn = require('wait-on');\nconst {spawn} = require('child_process');\nconst path = require('path');\n\nlet serverPi"
},
{
"path": "examples/test-app/index.html",
"chars": 2509,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n\n<head>\n <meta charset=\"UTF-8\" />\n <meta name=\"viewport\" content=\"width=device-width,"
},
{
"path": "examples/test-app/page2.html",
"chars": 250,
"preview": "<div>\n <h2>second page</h2>\n</div>\n<section>\n <section>\n <h2>configure</h2>\n <img data-automation-id"
},
{
"path": "examples/tests/README.md",
"chars": 288,
"preview": "# Using Mocha as a test runner in Nightwatch 2\n\nNightwatch 2 brings support for Mocha v9 as an alternative test runner w"
},
{
"path": "examples/tests/angularTodoTest.js",
"chars": 966,
"preview": "describe('angularjs homepage todo list', function() {\n\n it('should add a todo using custom commands', async function(br"
},
{
"path": "examples/tests/bstackdemo/auth.js",
"chars": 841,
"preview": "describe('Authentication Tests', function () {\n beforeEach((browser) => browser.navigateTo('https://www.bstackdemo.com'"
},
{
"path": "examples/tests/bstackdemo/checkout.js",
"chars": 1364,
"preview": "describe('Checkout Test', function () {\n before((browser) => browser.navigateTo('https://www.bstackdemo.com/'));\n\n it("
},
{
"path": "examples/tests/chromeCDP_example.js",
"chars": 434,
"preview": "describe('Chrome DevTools Example', function() {\n\n this.disabled = this.argv.env !== 'chrome';\n\n it ('using CDP DOM Sn"
},
{
"path": "examples/tests/duckDuckGo.js",
"chars": 491,
"preview": "describe('duckduckgo example', function() {\n\n this.tags = ['end-to-end'];\n\n it('Search Nightwatch.js and check results"
},
{
"path": "examples/tests/ecosia.js",
"chars": 553,
"preview": "describe('Ecosia.org Demo', function() {\n\n before(browser => {\n browser\n .navigateTo('https://www.ecosia.org/')"
},
{
"path": "examples/tests/element/dragAndDrop.js",
"chars": 1134,
"preview": "describe('Element Drag & Drop Demo', function () {\n before(browser => {\n browser.navigateTo(\n 'https://mdn.gith"
},
{
"path": "examples/tests/element/elementScreenshot.js",
"chars": 951,
"preview": "describe('Take Screenshot Demo', function () {\n before((browser) => {\n browser.navigateTo('https://nightwatchjs.org/"
},
{
"path": "examples/tests/element/elementapi-tests.js",
"chars": 3033,
"preview": "describe('queries tests', function() {\n\n beforeEach(function(browser) {\n browser.navigateTo('http://localhost:13370'"
},
{
"path": "examples/tests/element/isCommands.js",
"chars": 1149,
"preview": "describe('Element \"is\" commands Demo', function () {\n before((browser) => {\n browser.navigateTo('https://www.ecosia."
},
{
"path": "examples/tests/google.js",
"chars": 1521,
"preview": "describe('sample google search', function() {\n this.tags = ['google'];\n\n it('demo test using expect apis', async funct"
},
{
"path": "examples/tests/googlePageObject.js",
"chars": 726,
"preview": "describe('google search with consent form - page objects', function() {\n const homePage = browser.page.google.search();"
},
{
"path": "examples/tests/sample-with-relative-locators.js",
"chars": 881,
"preview": "/* eslint-disable no-undef */\ndescribe('sample with relative locators', function () {\n before(browser => browser.naviga"
},
{
"path": "examples/tests/selectElement.js",
"chars": 640,
"preview": "const {Select} = require('selenium-webdriver');\n\nmodule.exports = {\n before(browser) {\n browser.url('https://www.sel"
},
{
"path": "examples/tests/shadowRootExample.js",
"chars": 1846,
"preview": "describe('Shadow Root example test', function() {\n it('retrieve the shadowRoot', async function(browser) {\n browser\n"
},
{
"path": "examples/tests/vueTodoList.js",
"chars": 1693,
"preview": "/**\n * End-to-end test for the sample Vue3+Vite todo app located at\n * https://github.com/nightwatchjs-community/todo-vu"
},
{
"path": "examples/tsconfig.json",
"chars": 55,
"preview": "{\n \"extends\": \"../tsconfig\",\n \"include\": [\".\"]\n}\n"
},
{
"path": "examples/unittests/demoTestAsync.js",
"chars": 214,
"preview": "const assert = require('assert');\n\nmodule.exports = {\n '@unitTest': true,\n\n 'demo UnitTest': function (done) {\n ass"
},
{
"path": "examples/unittests/testUtils.js",
"chars": 816,
"preview": "const assert = require('assert');\nconst Utils = require('../../dist/utils/');\n\nmodule.exports = {\n testFormatElapsedTim"
},
{
"path": "examples/unittests/testUtilsWithChai.js",
"chars": 579,
"preview": "const Utils = require('../../dist/utils/');\nconst expect = require('chai').expect;\n\nmodule.exports = {\n testFormatElaps"
},
{
"path": "index.js",
"chars": 103,
"preview": "module.exports = process.env.NIGHTWATCH_COV ?\n require('./lib-cov/index') :\n require('./lib/index');\n"
},
{
"path": "lib/api/_loaders/_base-loader.js",
"chars": 13338,
"preview": "const path = require('path');\nconst fs = require('fs');\nconst EventEmitter = require('events');\nconst Utils = require('."
},
{
"path": "lib/api/_loaders/_command-loader.js",
"chars": 2859,
"preview": "const Element = require('../../element');\nconst BaseLoader = require('./_base-loader.js');\n\nclass BaseCommandLoader exte"
},
{
"path": "lib/api/_loaders/assertion-scheduler.js",
"chars": 5347,
"preview": "const Utils = require('../../utils');\nconst Element = require('../../element');\nconst {AssertionRunner} = require('../.."
},
{
"path": "lib/api/_loaders/assertion.js",
"chars": 5166,
"preview": "const {WebElementPromise} = require('selenium-webdriver');\n\nconst BaseCommandLoader = require('./_command-loader.js');\nc"
},
{
"path": "lib/api/_loaders/chrome.js",
"chars": 726,
"preview": "const BaseLoader = require('./_base-loader.js');\n\nclass ChromeCommandLoader extends BaseLoader {\n static get chromeComm"
},
{
"path": "lib/api/_loaders/command.js",
"chars": 8437,
"preview": "const EventEmitter = require('events');\nconst BaseCommandLoader = require('./_command-loader.js');\nconst {Logger, isES6A"
},
{
"path": "lib/api/_loaders/element-api.js",
"chars": 2309,
"preview": "const {Locator} = require('../../element');\nconst Utils = require('../../utils');\nconst ScopedWebElement = require('../w"
},
{
"path": "lib/api/_loaders/element-command.js",
"chars": 758,
"preview": "const CommandLoader = require('./command.js');\nconst ElementCommand = require('../../element').Command;\n\nclass ElementCo"
},
{
"path": "lib/api/_loaders/element-global.js",
"chars": 10283,
"preview": "const {until, WebElement} = require('selenium-webdriver');\nconst Utils = require('../../utils');\nconst {Logger, isUndefi"
},
{
"path": "lib/api/_loaders/ensure.js",
"chars": 7530,
"preview": "const util = require('util');\nconst {until, WebElement} = require('selenium-webdriver');\nconst EventEmitter = require('e"
},
{
"path": "lib/api/_loaders/expect-assertion.js",
"chars": 1941,
"preview": "const chaiNightwatch = require('chai-nightwatch');\nconst BaseLoader = require('./_base-loader.js');\n\nclass ExpectAsserti"
},
{
"path": "lib/api/_loaders/expect.js",
"chars": 4666,
"preview": "const chai = require('chai-nightwatch');\nconst path = require('path');\nconst fs = require('fs');\nconst Utils = require('"
},
{
"path": "lib/api/_loaders/firefox.js",
"chars": 465,
"preview": "const BaseLoader = require('./_base-loader.js');\n\nclass FirefoxCommandLoader extends BaseLoader {\n static get firefoxCo"
},
{
"path": "lib/api/_loaders/page-object.js",
"chars": 2129,
"preview": "const lodashMerge = require('lodash/merge');\nconst BaseLoader = require('./_base-loader.js');\nconst Page = require('../."
},
{
"path": "lib/api/_loaders/plugin.js",
"chars": 2279,
"preview": "const fs = require('fs');\nconst path = require('path');\nconst Utils = require('../../utils');\n\nconst __plugins = {};\n\nmo"
},
{
"path": "lib/api/_loaders/static.js",
"chars": 9954,
"preview": "const util = require('util');\nconst chai = require('@nightwatch/chai');\nconst assertModule = require('assert');\nconst Ev"
},
{
"path": "lib/api/_loaders/within-context.js",
"chars": 2615,
"preview": "const BaseLoader = require('./_base-loader.js');\nconst CommandWrapper = require('../../page-object/command-wrapper.js');"
},
{
"path": "lib/api/assertions/_assertionInstance.js",
"chars": 6436,
"preview": "const util = require('util');\nconst EventEmitter = require('events');\nconst Utils = require('../../utils');\nconst Elemen"
},
{
"path": "lib/api/assertions/attributeContains.js",
"chars": 1857,
"preview": "/**\n * Checks if the given attribute of an element contains the expected value.\n *\n * @example\n * this.demoTest = functi"
},
{
"path": "lib/api/assertions/attributeEquals.js",
"chars": 1794,
"preview": "/**\n * Checks if the given attribute of an element has the expected value.\n *\n * @example\n * this.demoTest = function (b"
},
{
"path": "lib/api/assertions/attributeMatches.js",
"chars": 1797,
"preview": "/**\n * Check if an element's attribute value matches a regular expression.\n *\n * @example\n * this.demoTest = function (b"
},
{
"path": "lib/api/assertions/contains.js",
"chars": 908,
"preview": "const Utils = require('../../utils/index.js');\n\nexports.assertion = function (actual, expected, message) {\n this.option"
},
{
"path": "lib/api/assertions/containsText.js",
"chars": 3362,
"preview": "/**\n * Checks if the given element contains the specified text.\n *\n * ```\n * this.demoTest = function (browser) {\n * "
},
{
"path": "lib/api/assertions/cssClassNotPresent.js",
"chars": 1703,
"preview": "/**\n * Checks if the given element does not have the specified CSS class.\n *\n * ```\n * this.demoTest = function (brow"
},
{
"path": "lib/api/assertions/cssClassPresent.js",
"chars": 2511,
"preview": "/**\n * Checks if the given element has the specified CSS class. Multiple css classes can be specified either as an array"
},
{
"path": "lib/api/assertions/cssProperty.js",
"chars": 1798,
"preview": "/**\n * Checks if the specified css property of a given element has the expected value.\n *\n * @example\n * this.demoTest ="
},
{
"path": "lib/api/assertions/domPropertyContains.js",
"chars": 2497,
"preview": "/**\n * Checks if the specified DOM property of a given element has the expected value. For all the available DOM element"
},
{
"path": "lib/api/assertions/domPropertyEquals.js",
"chars": 3297,
"preview": "/**\n * Checks if the specified DOM property of a given element has the expected value. For all the available DOM element"
},
{
"path": "lib/api/assertions/domPropertyMatches.js",
"chars": 2011,
"preview": "/**\n * Check if specified DOM property value of a given element matches a regex. For all the available DOM element prope"
},
{
"path": "lib/api/assertions/elementNotPresent.js",
"chars": 1467,
"preview": "/**\n * Checks if the given element does not exist in the DOM.\n *\n * ```\n * this.demoTest = function (browser) {\n * "
},
{
"path": "lib/api/assertions/elementPresent.js",
"chars": 1459,
"preview": "/**\n * Checks if the given element exists in the DOM.\n *\n * @example\n * this.demoTest = function (browser) {\n * browse"
},
{
"path": "lib/api/assertions/elementsCount.js",
"chars": 1569,
"preview": "/**\n * Checks if the number of elements specified by a selector is equal to a given value.\n *\n * @example\n * this.demoTe"
},
{
"path": "lib/api/assertions/enabled.js",
"chars": 1426,
"preview": "\n/**\n * Checks if the given element is enabled (as indicated by the 'disabled' attribute).\n *\n * @example\n * this.demoTe"
},
{
"path": "lib/api/assertions/hasAttribute.js",
"chars": 1808,
"preview": "\n/**\n * Checks if the given element contains the specified DOM attribute.\n *\n * Equivalent of: https://developer.mozilla"
},
{
"path": "lib/api/assertions/hasClass.js",
"chars": 2011,
"preview": "/**\n * Checks if the given element has the specified CSS class.\n *\n * @example\n * this.demoTest = function (browser) {\n "
},
{
"path": "lib/api/assertions/hasDescendants.js",
"chars": 1512,
"preview": "/**\n * Checks if the given element has child elements.\n *\n * @example\n * this.demoTest = function (browser) {\n * brows"
},
{
"path": "lib/api/assertions/hidden.js",
"chars": 1455,
"preview": "/**\n * Checks if the given element is not visible on the page.\n *\n * ```\n * this.demoTest = function (browser) {\n * "
},
{
"path": "lib/api/assertions/promisedValue.js",
"chars": 920,
"preview": "exports.assertion = function({callback, evaluate, expected, verb, message, failure = function() {}}) {\n this.options = "
},
{
"path": "lib/api/assertions/selected.js",
"chars": 1398,
"preview": "\n/**\n * Checks if the given element is selected.\n *\n * @example\n * this.demoTest = function (browser) {\n * browser.ass"
},
{
"path": "lib/api/assertions/textContains.js",
"chars": 3138,
"preview": "/**\n * Checks if the given element contains the specified text.\n *\n * @example\n * this.demoTest = function (browser) {\n "
},
{
"path": "lib/api/assertions/textEquals.js",
"chars": 1937,
"preview": "/**\n * Check if an element's inner text equals the expected text.\n *\n * @example\n * this.demoTest = function (browser) {"
},
{
"path": "lib/api/assertions/textMatches.js",
"chars": 1652,
"preview": "/**\n * Check if an elements inner text matches a regular expression.\n *\n * @example\n * this.demoTest = function (browser"
},
{
"path": "lib/api/assertions/title.js",
"chars": 1179,
"preview": "/**\n * Checks if the page title equals the given value.\n *\n * ```\n * this.demoTest = function (browser) {\n * bro"
},
{
"path": "lib/api/assertions/titleContains.js",
"chars": 1070,
"preview": "/**\n * Checks if the page title contains the given value.\n *\n * @example\n * this.demoTest = function (browser) {\n * br"
},
{
"path": "lib/api/assertions/titleEquals.js",
"chars": 987,
"preview": "/**\n * Checks if the page title equals the given value.\n *\n * @example\n * this.demoTest = function (client) {\n * brows"
},
{
"path": "lib/api/assertions/titleMatches.js",
"chars": 1156,
"preview": "/**\n * Checks if the current title matches a regular expression.\n *\n * @example\n * this.demoTest = function (client) {\n "
},
{
"path": "lib/api/assertions/urlContains.js",
"chars": 1126,
"preview": "/**\n * Checks if the current URL contains the given value.\n *\n * @example\n * this.demoTest = function (browser) {\n * b"
},
{
"path": "lib/api/assertions/urlEquals.js",
"chars": 956,
"preview": "/**\n * Checks if the current url equals the given value.\n *\n * @example\n * this.demoTest = function (client) {\n * brow"
},
{
"path": "lib/api/assertions/urlMatches.js",
"chars": 1118,
"preview": "/**\n * Checks if the current url matches a regular expression.\n *\n * @example\n * this.demoTest = function (client) {\n * "
},
{
"path": "lib/api/assertions/value.js",
"chars": 1877,
"preview": "/**\n * Checks if the given form element's value equals the expected value.\n *\n * ```\n * this.demoTest = function (bro"
},
{
"path": "lib/api/assertions/valueContains.js",
"chars": 1715,
"preview": "/**\n * Checks if the given form element's value contains the expected value.\n *\n * @example\n * this.demoTest = function "
},
{
"path": "lib/api/assertions/valueEquals.js",
"chars": 1592,
"preview": "\n/**\n * Checks if the given form element's value equals the expected value.\n *\n * The existing .assert.value() command.\n"
},
{
"path": "lib/api/assertions/visible.js",
"chars": 1521,
"preview": "/**\n * Checks if the given element is visible on the page.\n *\n * @example\n * this.demoTest = function (browser) {\n * b"
},
{
"path": "lib/api/client-commands/_base-command.js",
"chars": 3011,
"preview": "module.exports = class ClientCommand {\n static get isTraceable() {\n return false;\n }\n\n /**\n *\n * @param {funct"
},
{
"path": "lib/api/client-commands/_locateStrategy.js",
"chars": 316,
"preview": "const EventEmitter = require('events');\n\nclass Command extends EventEmitter {\n command(callback = function() {}) {\n "
},
{
"path": "lib/api/client-commands/alerts/accept.js",
"chars": 1021,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Accepts the currently displayed alert dialog. Usually, thi"
},
{
"path": "lib/api/client-commands/alerts/dismiss.js",
"chars": 1125,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Dismisses the currently displayed alert dialog.\n *\n * For "
},
{
"path": "lib/api/client-commands/alerts/getText.js",
"chars": 1091,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Get the text of the currently displayed JavaScript alert()"
},
{
"path": "lib/api/client-commands/alerts/setText.js",
"chars": 1345,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Send keystrokes to a JavaScript prompt() dialog.\n *\n * @ex"
},
{
"path": "lib/api/client-commands/axeInject.js",
"chars": 842,
"preview": "/**\n * Injects the [axe-core](https://github.com/dequelabs/axe-core) js library into the current page (using the `.execu"
},
{
"path": "lib/api/client-commands/axeRun.js",
"chars": 1284,
"preview": "/**\n * Analyzes the current page against applied axe rules.\n *\n * @example\n * describe('accessibility testing', function"
},
{
"path": "lib/api/client-commands/cookies/delete.js",
"chars": 1409,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Delete the cookie with the given name. This command is a n"
},
{
"path": "lib/api/client-commands/cookies/deleteAll.js",
"chars": 969,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Delete all cookies visible to the current page.\n *\n * @exa"
},
{
"path": "lib/api/client-commands/cookies/get.js",
"chars": 1775,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Retrieve a single cookie visible to the current page.\n *\n "
},
{
"path": "lib/api/client-commands/cookies/getAll.js",
"chars": 1414,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Retrieve all cookies visible to the current page.\n *\n * Th"
},
{
"path": "lib/api/client-commands/cookies/set.js",
"chars": 1840,
"preview": "const ClientCommand = require('../_base-command.js');\nconst Utils = require('../../../utils/index.js');\n\n/**\n * Set a co"
},
{
"path": "lib/api/client-commands/debug.js",
"chars": 3441,
"preview": "const EventEmitter = require('events');\nconst NightwatchRepl = require('../../testsuite/repl');\nconst Debuggability = re"
},
{
"path": "lib/api/client-commands/deleteCookie.js",
"chars": 1057,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Delete the cookie with the given name. This command is a no"
},
{
"path": "lib/api/client-commands/deleteCookies.js",
"chars": 774,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Delete all cookies visible to the current page.\n *\n * @exam"
},
{
"path": "lib/api/client-commands/document/executeAsyncScript.js",
"chars": 3202,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {isFunction} = require('../../../utils/index.js');\n\n/**\n * I"
},
{
"path": "lib/api/client-commands/document/executeScript.js",
"chars": 3247,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {isFunction} = require('../../../utils/index.js');\n\n/**\n * I"
},
{
"path": "lib/api/client-commands/document/injectScript.js",
"chars": 1963,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Utility command to load an external script into the page s"
},
{
"path": "lib/api/client-commands/document/source.js",
"chars": 1042,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Get the string serialized source of the current page.\n *\n "
},
{
"path": "lib/api/client-commands/enablePerformanceMetrics.js",
"chars": 1711,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Enable/disable the"
},
{
"path": "lib/api/client-commands/end.js",
"chars": 1276,
"preview": "const EventEmitter = require('events');\n\n/**\n * Ends the session. Uses session protocol command.\n *\n * @example\n * this."
},
{
"path": "lib/api/client-commands/getCookie.js",
"chars": 1867,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Retrieve a single cookie visible to the current page. The c"
},
{
"path": "lib/api/client-commands/getCookies.js",
"chars": 988,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Retrieve all cookies visible to the current page. The cooki"
},
{
"path": "lib/api/client-commands/getLog.js",
"chars": 1273,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Gets a log from Selenium.\n *\n * @example\n * this.demoTest ="
},
{
"path": "lib/api/client-commands/getLogTypes.js",
"chars": 927,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Gets the available log types. More info about log types in "
},
{
"path": "lib/api/client-commands/getPerformanceMetrics.js",
"chars": 1651,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Get the performanc"
},
{
"path": "lib/api/client-commands/getTitle.js",
"chars": 760,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Returns the title of the current page. Uses title protocol "
},
{
"path": "lib/api/client-commands/getWindowPosition.js",
"chars": 1342,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Retrieves the current window position.\n *\n * For clients wh"
},
{
"path": "lib/api/client-commands/getWindowRect.js",
"chars": 1555,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Change or get the [window rect](https://w3c.github.io/webdr"
},
{
"path": "lib/api/client-commands/getWindowSize.js",
"chars": 1297,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Retrieves the current window size.\n *\n * For clients which "
},
{
"path": "lib/api/client-commands/init.js",
"chars": 1209,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * This command is an alias to url and also a convenience meth"
},
{
"path": "lib/api/client-commands/injectScript.js",
"chars": 1369,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Utility command to load an external script into the page sp"
},
{
"path": "lib/api/client-commands/isLogAvailable.js",
"chars": 1305,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Utility command to test if the log type is available.\n *\n *"
},
{
"path": "lib/api/client-commands/logs/captureBrowserConsoleLogs.js",
"chars": 1833,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {Logger} = require('../../../utils');\n\n/**\n * Listen to the "
},
{
"path": "lib/api/client-commands/logs/captureBrowserExceptions.js",
"chars": 2039,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {Logger} = require('../../../utils');\n\n/**\n * Catch the Java"
},
{
"path": "lib/api/client-commands/logs/getSessionLog.js",
"chars": 2036,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Gets a log from Selenium.\n *\n * @example\n * describe('get "
},
{
"path": "lib/api/client-commands/logs/getSessionLogTypes.js",
"chars": 1156,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Gets the available log types. More info about log types in"
},
{
"path": "lib/api/client-commands/logs/isSessionLogAvailable.js",
"chars": 1918,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Utility command to test if the log type is available.\n *\n "
},
{
"path": "lib/api/client-commands/maximizeWindow.js",
"chars": 584,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Maximizes the current window.\n *\n * @example\n * this.demoT"
},
{
"path": "lib/api/client-commands/network/captureRequests.js",
"chars": 2063,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {Logger} = require('../../../utils');\n\n/**\n * Capture outgoi"
},
{
"path": "lib/api/client-commands/network/mockResponse.js",
"chars": 2288,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {Logger} = require('../../../utils');\n\n/**\n * Intercept the "
},
{
"path": "lib/api/client-commands/network/setConditions.js",
"chars": 1380,
"preview": "const ClientCommand = require('../_base-command.js');\nconst {Logger} = require('../../../utils');\n\n/**\n *\n * Command to "
},
{
"path": "lib/api/client-commands/pageSource.js",
"chars": 724,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Returns the page source.\n *\n * @example\n * this.demoTest ="
},
{
"path": "lib/api/client-commands/pause.js",
"chars": 3207,
"preview": "const EventEmitter = require('events');\nconst readline = require('readline');\nconst Debuggability = require('../../utils"
},
{
"path": "lib/api/client-commands/perform.js",
"chars": 4200,
"preview": "/**\n * A simple perform command which allows access to the Nightwatch API in a callback. Can be useful if you want to re"
},
{
"path": "lib/api/client-commands/registerBasicAuth.js",
"chars": 1609,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Automate the input"
},
{
"path": "lib/api/client-commands/resizeWindow.js",
"chars": 985,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Resizes the current window.\n *\n * @example\n * this.demoTes"
},
{
"path": "lib/api/client-commands/saveScreenshot.js",
"chars": 1610,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger, writeToFile} = require('../../utils');\nconst {COMMON"
},
{
"path": "lib/api/client-commands/saveSnapshot.js",
"chars": 2554,
"preview": "const {URL} = require('url');\nconst {JSDOM} = require('jsdom');\nconst ClientCommand = require('./_base-command.js');\ncon"
},
{
"path": "lib/api/client-commands/setCookie.js",
"chars": 1261,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Set a cookie, specified as a cookie JSON object, as defined"
},
{
"path": "lib/api/client-commands/setDeviceDimensions.js",
"chars": 2082,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Override device mo"
},
{
"path": "lib/api/client-commands/setGeolocation.js",
"chars": 2505,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Mock the geolocati"
},
{
"path": "lib/api/client-commands/setWindowPosition.js",
"chars": 894,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Sets the current window position.\n *\n * @example\n * this.d"
},
{
"path": "lib/api/client-commands/setWindowRect.js",
"chars": 2096,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Change the [window rect](https://w3c.github.io/webdriver/#d"
},
{
"path": "lib/api/client-commands/setWindowSize.js",
"chars": 868,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Sets the current window size in CSS pixels.\n *\n * @example\n"
},
{
"path": "lib/api/client-commands/takeHeapSnapshot.js",
"chars": 1817,
"preview": "const ClientCommand = require('./_base-command.js');\nconst {Logger} = require('../../utils');\n\n/**\n * Take heap snapshot"
},
{
"path": "lib/api/client-commands/urlHash.js",
"chars": 1029,
"preview": "const ClientCommand = require('./_base-command.js');\n\n/**\n * Convenience command that adds the specified hash (i.e. url "
},
{
"path": "lib/api/client-commands/useCss.js",
"chars": 715,
"preview": "const LocateStrategy = require('./_locateStrategy.js');\nconst Strategies = require('../../element').LocateStrategy;\n\n/**"
},
{
"path": "lib/api/client-commands/useXpath.js",
"chars": 730,
"preview": "const LocateStrategy = require('./_locateStrategy.js');\nconst Strategies = require('../../element').LocateStrategy;\n\n/**"
},
{
"path": "lib/api/client-commands/window/close.js",
"chars": 1122,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Close the current window or tab. This can be useful when y"
},
{
"path": "lib/api/client-commands/window/fullscreen.js",
"chars": 954,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Set the current window state to fullscreen, similar to pre"
},
{
"path": "lib/api/client-commands/window/getAllHandles.js",
"chars": 1108,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Retrieve the list of all window handles available to the s"
},
{
"path": "lib/api/client-commands/window/getHandle.js",
"chars": 1237,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Retrieve the current window handle.\n *\n * WebDriver does n"
},
{
"path": "lib/api/client-commands/window/getPosition.js",
"chars": 1111,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Get the coordinates of the top left corner of the current "
},
{
"path": "lib/api/client-commands/window/getRect.js",
"chars": 1581,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Fetches the [window rect](https://w3c.github.io/webdriver/"
},
{
"path": "lib/api/client-commands/window/getSize.js",
"chars": 1054,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Get the size of the current window in pixels.\n *\n * @examp"
},
{
"path": "lib/api/client-commands/window/maximize.js",
"chars": 923,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Increases the window to the maximum available size without"
},
{
"path": "lib/api/client-commands/window/minimize.js",
"chars": 1045,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Hides the window in the system tray. If the window happens"
},
{
"path": "lib/api/client-commands/window/open.js",
"chars": 1820,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Opens a new tab (default) or a separate new window, and ch"
},
{
"path": "lib/api/client-commands/window/setPosition.js",
"chars": 1560,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Set the position of the current window - move the window t"
},
{
"path": "lib/api/client-commands/window/setRect.js",
"chars": 3449,
"preview": "const ClientCommand = require('../_base-command.js');\nconst Utils = require('../../../utils/index.js');\n\n/**\n * Change t"
},
{
"path": "lib/api/client-commands/window/setSize.js",
"chars": 1452,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Set the size of the current window in CSS pixels.\n *\n * @e"
},
{
"path": "lib/api/client-commands/window/switchTo.js",
"chars": 3460,
"preview": "const ClientCommand = require('../_base-command.js');\n\n/**\n * Change focus to another window.\n *\n * The window to change"
},
{
"path": "lib/api/client-commands/within.js",
"chars": 834,
"preview": "/**\n * Returns a context for the given element which can be used for querying child elements.\n *\n * @example\n * describe"
},
{
"path": "lib/api/element-commands/_baseElementCommand.js",
"chars": 4728,
"preview": "const {WebElement} = require('selenium-webdriver');\nconst ElementCommand = require('../../element').Command;\nconst Utils"
},
{
"path": "lib/api/element-commands/_waitFor.js",
"chars": 8039,
"preview": "const Utils = require('../../utils');\nconst {AssertionRunner} = require('../../assertion');\nconst {LocateStrategy, Comma"
},
{
"path": "lib/api/element-commands/_waitForDisplayed.js",
"chars": 1746,
"preview": "const WaitForElement = require('./_waitFor.js');\n\nclass WaitForDisplayed extends WaitForElement {\n protocolAction() {\n "
}
]
// ... and 1047 more files (download for full content)
About this extraction
This page contains the full source code of the nightwatchjs/nightwatch GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1247 files (4.7 MB), approximately 1.3M tokens, and a symbol index with 4183 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.