• Version 8.37.0
  • Published
  • 296 kB
  • 24 dependencies
  • MIT license


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


WebdriverIO testrunner command line interface



function run

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


    class Launcher

    class Launcher {}


      _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


                  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<
                                            '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 isUsingBabel

                                                              isUsingBabel: 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 isUsingCompiler

                                                                                                                                            isUsingCompiler: CompilerOptions;

                                                                                                                                              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 autoCompileOpts

                                                                                                                                                                                                  autoCompileOpts?: Options.AutoCompileConfig;

                                                                                                                                                                                                    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 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.


                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                          • 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>