@wdio/cli

  • Version 10.0.2
  • Published
  • 112 kB
  • 21 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<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 initialize

                  initialize: () => Promise<void>;
                  • initialize launcher by loading tsx only when TypeScript is involved

                  method run

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

                  Interfaces

                  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 ProjectProps

                                    interface ProjectProps {}

                                      property esmSupported

                                      esmSupported: boolean;

                                        property packageJson

                                        packageJson: NormalizedPackageJson;

                                          property path

                                          path: string;

                                            interface ReplCommandArguments

                                            interface ReplCommandArguments {}

                                              property capabilities

                                              capabilities: string;

                                                property deviceName

                                                deviceName: string;

                                                  property option

                                                  option: string;

                                                    property platformVersion

                                                    platformVersion: string;

                                                      property session

                                                      session?: 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 cpuProf

                                                                    cpuProf?: boolean;

                                                                      property cucumberOpts

                                                                      cucumberOpts?: WebdriverIO.CucumberOpts;

                                                                        property debug

                                                                        debug?: 'agent';
                                                                        • wdio run --debug=agent pauses browser.debug() and failing tests.

                                                                        property exclude

                                                                        exclude?: string[];

                                                                          property framework

                                                                          framework?: string;

                                                                            property headless

                                                                            headless?: boolean;

                                                                              property heapProf

                                                                              heapProf?: boolean;

                                                                                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 SUPPORTED_PACKAGE_MANAGERS)[number];

                                                                                                                          type ValueKeyIteratee

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

                                                                                                                          Package Files (4)

                                                                                                                          Dependencies (21)

                                                                                                                          Dev Dependencies (5)

                                                                                                                          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>