@wdio/cli

  • Version 9.4.2
  • Published
  • 262 kB
  • 24 dependencies
  • MIT license

Install

npm i @wdio/cli
yarn add @wdio/cli
pnpm add @wdio/cli

Overview

WebdriverIO testrunner command line interface

Index

Functions

function run

run: () => Promise<false | void>;

    Classes

    class Launcher

    class Launcher {}

      constructor

      constructor(
      _configFilePath: string,
      _args?: Partial<RunCommandArguments>,
      _isWatchMode?: boolean
      );

        property configParser

        configParser: ConfigParser;

          property interface

          interface?: CLInterface;

            property isMultiremote

            isMultiremote: boolean;

              property isParallelMultiremote

              isParallelMultiremote: boolean;

                property runner

                runner?: Services.RunnerInstance;

                  method run

                  run: () => Promise<undefined | number>;
                  • run sequence {Promise} that only gets resolved with either an exitCode or an error

                  Interfaces

                  interface ConfigCommandArguments

                  interface ConfigCommandArguments {}

                    property npmTag

                    npmTag: string;

                      property yarn

                      yarn: boolean;

                        property yes

                        yes: boolean;

                          interface InstallCommandArguments

                          interface InstallCommandArguments {}

                            property config

                            config?: string;

                              property name

                              name: string;

                                property type

                                type: 'service' | 'reporter' | 'framework' | 'plugin';

                                  interface OnCompleteResult

                                  interface OnCompleteResult {}

                                    property failed

                                    failed: number;

                                      property finished

                                      finished: number;

                                        property passed

                                        passed: number;

                                          property retries

                                          retries: number;

                                            interface ParsedAnswers

                                            interface ParsedAnswers
                                            extends Omit<
                                            Questionnair,
                                            'runner' | 'framework' | 'reporters' | 'services' | 'plugins'
                                            > {}

                                              property destPageObjectRootPath

                                              destPageObjectRootPath: string;

                                                property destSerenityLibRootPath

                                                destSerenityLibRootPath: string;

                                                  property destSpecRootPath

                                                  destSpecRootPath: string;

                                                    property destStepRootPath

                                                    destStepRootPath: string;

                                                      property esmSupport

                                                      esmSupport: boolean;

                                                        property framework

                                                        framework: string;

                                                          property hasRootTSConfig

                                                          hasRootTSConfig: boolean;

                                                            property isSync

                                                            isSync: boolean;

                                                              property isUsingTypeScript

                                                              isUsingTypeScript: boolean;

                                                                property packagesToInstall

                                                                packagesToInstall: string[];

                                                                  property plugins

                                                                  plugins: string[];

                                                                    property projectName

                                                                    projectName: string;

                                                                      property projectRootDir

                                                                      projectRootDir: string;

                                                                        property purpose

                                                                        purpose: string;

                                                                          property rawAnswers

                                                                          rawAnswers: Questionnair;

                                                                            property relativePath

                                                                            relativePath: string;

                                                                              property reporters

                                                                              reporters: string[];

                                                                                property runner

                                                                                runner: 'local' | 'browser';

                                                                                  property serenityAdapter

                                                                                  serenityAdapter: string | false;

                                                                                    property services

                                                                                    services: string[];

                                                                                      property tsConfigFilePath

                                                                                      tsConfigFilePath: string;

                                                                                        property tsProject

                                                                                        tsProject: string;

                                                                                          property wdioConfigPath

                                                                                          wdioConfigPath: string;

                                                                                            interface ProjectProps

                                                                                            interface ProjectProps {}

                                                                                              property esmSupported

                                                                                              esmSupported: boolean;

                                                                                                property packageJson

                                                                                                packageJson: NormalizedPackageJson;

                                                                                                  property path

                                                                                                  path: string;

                                                                                                    interface Questionnair

                                                                                                    interface Questionnair {}

                                                                                                      property backend

                                                                                                      backend?: BackendChoice;

                                                                                                        property browserEnvironment

                                                                                                        browserEnvironment?: ('chrome' | 'firefox' | 'safari' | 'microsoftedge')[];

                                                                                                          property createPackageJSON

                                                                                                          createPackageJSON?: boolean;

                                                                                                            property e2eEnvironment

                                                                                                            e2eEnvironment?: 'web' | 'mobile';

                                                                                                              property electronAppBinaryPath

                                                                                                              electronAppBinaryPath?: string;

                                                                                                                property electronBuilderConfigPath

                                                                                                                electronBuilderConfigPath?: string;

                                                                                                                  property electronBuildTool

                                                                                                                  electronBuildTool?: ElectronBuildToolChoice;

                                                                                                                    property env_key

                                                                                                                    env_key?: string;

                                                                                                                      property env_user

                                                                                                                      env_user?: string;

                                                                                                                        property expEnvAccessKey

                                                                                                                        expEnvAccessKey?: string;

                                                                                                                          property expEnvHostname

                                                                                                                          expEnvHostname?: string;

                                                                                                                            property expEnvPort

                                                                                                                            expEnvPort?: string;

                                                                                                                              property expEnvProtocol

                                                                                                                              expEnvProtocol?: 'http' | 'https';

                                                                                                                                property framework

                                                                                                                                framework: string;

                                                                                                                                  property generateTestFiles

                                                                                                                                  generateTestFiles: boolean;

                                                                                                                                    property hostname

                                                                                                                                    hostname?: string;

                                                                                                                                      property includeVisualTesting

                                                                                                                                      includeVisualTesting: boolean;

                                                                                                                                        property installTestingLibrary

                                                                                                                                        installTestingLibrary?: boolean;

                                                                                                                                          property isUsingTypeScript

                                                                                                                                          isUsingTypeScript: boolean;

                                                                                                                                            property mobileEnvironment

                                                                                                                                            mobileEnvironment?: 'android' | 'ios';

                                                                                                                                              property npmInstall

                                                                                                                                              npmInstall: boolean;

                                                                                                                                                property outputDir

                                                                                                                                                outputDir?: string;

                                                                                                                                                  property pages

                                                                                                                                                  pages?: string;

                                                                                                                                                    property path

                                                                                                                                                    path?: string;

                                                                                                                                                      property plugins

                                                                                                                                                      plugins: string[];

                                                                                                                                                        property port

                                                                                                                                                        port?: string;

                                                                                                                                                          property preset

                                                                                                                                                          preset?: string;

                                                                                                                                                            property projectRoot

                                                                                                                                                            projectRoot?: string;

                                                                                                                                                              property projectRootCorrect

                                                                                                                                                              projectRootCorrect?: boolean;

                                                                                                                                                                property region

                                                                                                                                                                region?: RegionOptions;

                                                                                                                                                                  property reporters

                                                                                                                                                                  reporters: string[];

                                                                                                                                                                    property runner

                                                                                                                                                                    runner: string;

                                                                                                                                                                      property serenityLibPath

                                                                                                                                                                      serenityLibPath?: string;

                                                                                                                                                                        property services

                                                                                                                                                                        services: string[];

                                                                                                                                                                          property specs

                                                                                                                                                                          specs?: string;

                                                                                                                                                                            property stepDefinitions

                                                                                                                                                                            stepDefinitions?: string;

                                                                                                                                                                              property usePageObjects

                                                                                                                                                                              usePageObjects?: boolean;

                                                                                                                                                                                property useSauceConnect

                                                                                                                                                                                useSauceConnect?: boolean;

                                                                                                                                                                                  interface ReplCommandArguments

                                                                                                                                                                                  interface ReplCommandArguments {}

                                                                                                                                                                                    property capabilities

                                                                                                                                                                                    capabilities: string;

                                                                                                                                                                                      property deviceName

                                                                                                                                                                                      deviceName: string;

                                                                                                                                                                                        property option

                                                                                                                                                                                        option: string;

                                                                                                                                                                                          property platformVersion

                                                                                                                                                                                          platformVersion: string;

                                                                                                                                                                                            property udid

                                                                                                                                                                                            udid: string;

                                                                                                                                                                                              interface RunCommandArguments

                                                                                                                                                                                              interface RunCommandArguments {}

                                                                                                                                                                                                property bail

                                                                                                                                                                                                bail?: number;

                                                                                                                                                                                                  property baseUrl

                                                                                                                                                                                                  baseUrl?: string;

                                                                                                                                                                                                    property configPath

                                                                                                                                                                                                    configPath: string;

                                                                                                                                                                                                      property coverage

                                                                                                                                                                                                      coverage?: boolean;

                                                                                                                                                                                                        property cucumberOpts

                                                                                                                                                                                                        cucumberOpts?: WebdriverIO.CucumberOpts;

                                                                                                                                                                                                          property exclude

                                                                                                                                                                                                          exclude?: string[];

                                                                                                                                                                                                            property framework

                                                                                                                                                                                                            framework?: string;

                                                                                                                                                                                                              property hostname

                                                                                                                                                                                                              hostname?: string;

                                                                                                                                                                                                                property jasmineOpts

                                                                                                                                                                                                                jasmineOpts?: WebdriverIO.JasmineOpts;

                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                  key?: string;

                                                                                                                                                                                                                    property logLevel

                                                                                                                                                                                                                    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';

                                                                                                                                                                                                                      property mochaOpts

                                                                                                                                                                                                                      mochaOpts?: WebdriverIO.MochaOpts;

                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                        path?: string;

                                                                                                                                                                                                                          property port

                                                                                                                                                                                                                          port?: number;

                                                                                                                                                                                                                            property reporters

                                                                                                                                                                                                                            reporters?: Reporters.ReporterEntry[];

                                                                                                                                                                                                                              property shard

                                                                                                                                                                                                                              shard?: Options.ShardOptions;

                                                                                                                                                                                                                                property spec

                                                                                                                                                                                                                                spec?: string[];

                                                                                                                                                                                                                                  property suite

                                                                                                                                                                                                                                  suite?: string[];

                                                                                                                                                                                                                                    property tsConfigPath

                                                                                                                                                                                                                                    tsConfigPath?: string;

                                                                                                                                                                                                                                      property updateSnapshots

                                                                                                                                                                                                                                      updateSnapshots?: Options.Testrunner['updateSnapshots'];

                                                                                                                                                                                                                                        property user

                                                                                                                                                                                                                                        user?: string;

                                                                                                                                                                                                                                          property waitforTimeout

                                                                                                                                                                                                                                          waitforTimeout?: number;

                                                                                                                                                                                                                                            property watch

                                                                                                                                                                                                                                            watch?: boolean;

                                                                                                                                                                                                                                              interface SupportedPackage

                                                                                                                                                                                                                                              interface SupportedPackage {}

                                                                                                                                                                                                                                                property package

                                                                                                                                                                                                                                                package: string;

                                                                                                                                                                                                                                                  property purpose

                                                                                                                                                                                                                                                  purpose: string;

                                                                                                                                                                                                                                                    property short

                                                                                                                                                                                                                                                    short: string;

                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                      type PM

                                                                                                                                                                                                                                                      type PM = (typeof PMs)[number];

                                                                                                                                                                                                                                                        type ValueKeyIteratee

                                                                                                                                                                                                                                                        type ValueKeyIteratee<T> =
                                                                                                                                                                                                                                                        | ((value: T, key: string) => NotVoid)
                                                                                                                                                                                                                                                        | IterateeShorthand<T>;
                                                                                                                                                                                                                                                        • Extracted from @types/lodash@4.14.168

                                                                                                                                                                                                                                                        Package Files (4)

                                                                                                                                                                                                                                                        Dependencies (24)

                                                                                                                                                                                                                                                        Dev Dependencies (8)

                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@wdio/cli.

                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@wdio/cli)
                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@wdio/cli"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>