@wdio/cli

  • Version 8.24.3
  • Published
  • 288 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 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 baseUrl

                                                                                                          baseUrl: string;

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