【WebDriver.io】集成browserstack后怎么运行

注意 windows上 要在 power shell 上运行才算是linux，如果是在系统内部运行属于cmd 会显示 'export' 不是内部或外部命令，也不是可运行的程序

 

第一种方式：

先安装对应的 第三方包

npm install

 

默认使用browserstack 所以当前应该先在本地跑命令把当前使用selenium先用起来

mac使用

export USE_SELENIUM=true

windows只能使用点开框的方式去做

设置完之后只需要重启使用的软件 就可以对当前的环境变量进行修改

 

打印出当前的环境变量

mac

printenv 

windows

  set

 

 

 

如果我要switch branch，切换终端等于重新开始，也要先确定一下当前的环境变量 比如USE_SELENIUM 参数是不是为true 没有的话 可以再设置一次

 

 

 

 

 

 

 

 

 

第二种方式：

增加自己的脚本命令行

 

可以使用 npm run  testSelenium  也可以自己增加对应的脚本

package.json

{
    "name": "portal-functional-tests",
    "version": "2.0.0",
    "private": true,
    "main": "index.js",
    "scripts": {
        "test": "wdio run wdio.conf.js",
        "local": "wdio run wdio.conf.js --skipSeleniumInstall true",
        "report": "allure generate allure-results --clean",
        "allure": "allure generate allure-results --clean  && allure open",
        "prelocal": "rimraf ./allure-results",
        "testBrowserStack": "npm run test -- --platform web --maxInstances 4",
        "testSelenium": "export USE_SELENIUM=true && npm run test -- --platform web --maxInstances 5 --headlesss"
    },
    "author": "Xiangyu Li",
    "license": "ISC",
    "devDependencies": {
        "@babel/core": "^7.16.0",
        "@babel/preset-env": "^7.16.0",
        "@babel/register": "^7.16.0",
        "@wdio/allure-reporter": "^7.16.6",
        "@wdio/appium-service": "^7.16.11",
        "@wdio/browserstack-service": "^8.10.5",
        "@wdio/cli": "^7.16.6",
        "@wdio/cucumber-framework": "^7.16.6",
        "@wdio/local-runner": "^7.16.6",
        "@wdio/selenium-standalone-service": "^7.19.1",
        "allure-commandline": "^2.13.8",
        "appium": "^1.22.1",
        "axios": "^0.24.0",
        "kill-port": "^1.6.1",
        "selenium-standalone": "^8.3.0",
        "sharp": "^0.30.0",
        "tesseract.js": "^2.1.5"
    },
    "dependencies": {
        "node-xlsx": "^0.21.0",
        "qs": "^6.11.0"
    }
}

 

 

 

 

 

 

 

 

 

 

wdio.conf

const { checkAdbIsOn } = require("./utils/util");
const { adbConnect } = require("./utils/adbHelper");
const { AppiumHelper } = require("./utils/appiumHelper");
const platform = process.argv.indexOf('--platform') != -1 ? process.argv[process.argv.indexOf('--platform') + 1] : '**'
const feature = process.argv.indexOf('--feature') != -1 ? process.argv[process.argv.indexOf('--feature') + 1] : '*'
const seleniumCapabilities = [
    {
        maxInstances:
            process.argv.indexOf("--maxInstances") !== -1
                ? parseInt(process.argv[process.argv.indexOf("--maxInstances") + 1]) : 1,

        browserName: "chrome",
        "goog:chromeOptions": {
            args:
                process.argv.indexOf("--headless") !== -1
                    ? [
                        "--headless",
                        "--no-sandbox",
                        "--disable-dev-shm-usage",
                        "--disable-gpu",
                        "--window-size=1600,1024",
                    ]
                    : ["--window-size=1600,1024"],
            prefs: {
                "intl.accept_languages": "en,en_US",
                "download.default_directory":
                    process.cwd().toString() + "/testdata/downloadResources",
            },
        },
        acceptInsecureCerts: true,
    },
];
const seleniumService = [
    "selenium-standalone",
    {
        drivers: { chrome: "latest" },
        skipSeleniumInstall:
            process.argv.indexOf("--skipSeleniumInstall") !== -1
                ? process.argv[process.argv.indexOf("--skipSeleniumInstall") + 1]
                : false,
    },
];
const browserStackCapabilities = [
    {
        browserName: 'Chrome',
        'bstack:options': {
            os: 'Windows',
            osVersion: '11',
            browserVersion: '112.0',
            buildName: "PromWeb",
            buildIdentifier: "${BUILD_NUMBER}",
            projectName: "PromWeb"
        }
    },
    {
        browserName: 'Firefox',
        'bstack:options': {
            os: 'Windows',
            osVersion: '11',
            browserVersion: '112.0',
            buildName: "PromWeb",
            buildIdentifier: "${BUILD_NUMBER}",
            projectName: "PromWeb"
        }
    },
    {
        browserName: 'Safari',
        'bstack:options': {
            os: 'OS X',
            osVersion: 'Big Sur',
            browserVersion: '14.1',
            buildName: "promWeb",
            buildIdentifier: "${BUILD_NUMBER}",
            projectName: "PromWeb"
        }
    }
];
const browserStackService = [
    "browserstack",
    {
        browserstackLocal: true,
        opts: { forcelocal: false }
    },
];


exports.config = {
    user: process.env.BROWSERSTACK_USERNAME,
    key: process.env.BROWSERSTACK_ACCESS_KEY,
    host: 'hub.browserstack.com',
    //
    // ====================
    // Runner Configuration
    // ====================
    //
    //
    // ==================
    // Specify Test Files
    // ==================
    // Define which test specs should run. The pattern is relative to the directory
    // from which `wdio` was called.
    //
    // The specs are defined as an array of spec files (optionally using wildcards
    // that will be expanded). The test for each spec file will be run in a separate
    // worker process. In order to have a group of spec files run in the same worker
    // process simply enclose them in an array within the specs array.
    //
    // If you are calling `wdio` from an NPM script (see https://docs.npmjs.com/cli/run-script),
    // then the current working directory is where your `package.json` resides, so `wdio`
    // will be called from there.
    //
    specs: [`./tests/features/${platform}/**/${feature}.feature`],
    // Patterns to exclude.
    exclude: [
        // 'path/to/excluded/files'
    ],
    //
    // ============
    // Capabilities
    // ============
    // Define your capabilities here. WebdriverIO can run multiple capabilities at the same
    // time. Depending on the number of capabilities, WebdriverIO launches several test
    // sessions. Within your capabilities you can overwrite the spec and exclude options in
    // order to group specific specs to a specific capability.
    //
    // First, you can define how many instances should be started at the same time. Let's
    // say you have 3 different capabilities (Chrome, Firefox, and Safari) and you have
    // set maxInstances to 1; wdio will spawn 3 processes. Therefore, if you have 10 spec
    // files and you set maxInstances to 10, all spec files will get tested at the same time
    // and 30 processes will get spawned. The property handles how many capabilities
    // from the same test should run tests.
    //
    maxInstances: (process.argv.indexOf('--maxInstances') != -1) ? parseInt(process.argv[process.argv.indexOf('--maxInstances') + 1]) : 1,
    //
    // If you have trouble getting all important capabilities together, check out the
    // Sauce Labs platform configurator - a great tool to configure your capabilities:
    // https://saucelabs.com/platform/platform-configurator
    //
    capabilities:
        process.env.USE_SELENIUM
            ? seleniumCapabilities
            : browserStackCapabilities,

    //
    // ===================
    // Test Configurations
    // ===================
    // Define all options that are relevant for the WebdriverIO instance here
    //
    // Level of logging verbosity: trace | debug | info | warn | error | silent
    logLevel: 'warn',
    //
    // Set specific log levels per logger
    // loggers:
    // - webdriver, webdriverio
    // - @wdio/browserstack-service, @wdio/devtools-service, @wdio/sauce-service
    // - @wdio/mocha-framework, @wdio/jasmine-framework
    // - @wdio/local-runner
    // - @wdio/sumologic-reporter
    // - @wdio/cli, @wdio/config, @wdio/utils
    // Level of logging verbosity: trace | debug | info | warn | error | silent
    // logLevels: {
    //     webdriver: 'info',
    //     '@wdio/appium-service': 'info'
    // },
    //
    // If you only want to run your tests until a specific amount of tests have failed use
    // bail (default is 0 - don't bail, run all tests).
    bail: 0,
    //
    // Set a base URL in order to shorten url command calls. If your `url` parameter starts
    // with `/`, the base url gets prepended, not including the path portion of your baseUrl.
    // If your `url` parameter starts without a scheme or `/` (like `some/path`), the base url
    // gets prepended directly.
    baseUrl: 'http://localhost',
    //
    // Default timeout for all waitFor* commands.
    waitforTimeout: 10000,
    //
    // Default timeout in milliseconds for request
    // if browser driver or grid doesn't send response
    connectionRetryTimeout: 1200000,
    //
    // Default request retries count
    connectionRetryCount: 3,
    //
    // Appium port
    // port: 4723,
    // path: '/wd/hub',
    //
    // Test runner services
    // Services take over a specific job you don't want to take care of. They enhance
    // your test setup with almost no effort. Unlike plugins, they don't add new
    // commands. Instead, they hook themselves up into the test process.
    services:
        process.env.USE_SELENIUM
            ? [seleniumService]
            : [browserStackService],

    // Framework you want to run your specs with.
    // The following are supported: Mocha, Jasmine, and Cucumber
    // see also: https://webdriver.io/docs/frameworks
    //
    // Make sure you have the wdio adapter package for the specific framework installed
    // before running any tests.
    framework: 'cucumber',
    //
    // The number of times to retry the entire specfile when it fails as a whole
    // specFileRetries: 1,
    //
    // Delay in seconds between the spec file retry attempts
    // specFileRetriesDelay: 0,
    //
    // Whether or not retried specfiles should be retried immediately or deferred to the end of the queue
    // specFileRetriesDeferred: false,
    //
    // Test reporter for stdout.
    // The only one supported by default is 'dot'
    // see also: https://webdriver.io/docs/dot-reporter
    reporters: [['allure', {
        outputDir: 'allure-results',
        disableWebdriverStepsReporting: false,
        disableWebdriverScreenshotsReporting: false,
    }]],


    //
    // If you are using Cucumber you need to specify the location of your step definitions.
    cucumberOpts: {
        // <string[]> (file/dir) require files before executing features
        require: ['./tests/steps/**/*.js'],
        // <boolean> show full backtrace for errors
        backtrace: false,
        // <string[]> ("extension:module") require files with the given EXTENSION after requiring MODULE (repeatable)
        requireModule: [],
        // <boolean> invoke formatters without executing steps
        dryRun: false,
        // <boolean> abort the run on first failure
        failFast: false,
        // <string[]> (type[:path]) specify the output format, optionally supply PATH to redirect formatter output (repeatable)
        format: ['pretty'],
        // <boolean> hide step definition snippets for pending steps
        snippets: true,
        // <boolean> hide source uris
        source: true,
        // <string[]> (name) specify the profile to use
        profile: [],
        // <boolean> fail if there are any undefined or pending steps
        strict: false,
        // <string> (expression) only execute the features or scenarios with tags matching the expression
        tagExpression: process.argv.indexOf('--tag') != -1 ? `@${process.argv[process.argv.indexOf('--tag') + 1]}` : 'not @skip',
        // <number> timeout for step definitions
        timeout: 180000,
        // <boolean> Enable this config to treat undefined definitions as warnings.
        ignoreUndefinedDefinitions: false
    },

    //
    // =====
    // Hooks
    // =====
    // WebdriverIO provides several hooks you can use to interfere with the test process in order to enhance
    // it and to build services around it. You can either apply a single function or an array of
    // methods to it. If one of them returns with a promise, WebdriverIO will wait until that promise got
    // resolved to continue.
    /**
     * Gets executed once before all workers get launched.
     * @param {Object} config wdio configuration object
     * @param {Array.<Object>} capabilities list of capabilities details
     */
    // onPrepare: async function (config, capabilities) { 
    // },
    /**
     * Gets executed before a worker process is spawned and can be used to initialise specific service
     * for that worker as well as modify runtime environments in an async fashion.
     * @param  {String} cid      capability id (e.g 0-0)
     * @param  {[type]} caps     object containing capabilities for session that will be spawn in the worker
     * @param  {[type]} specs    specs to be run in the worker process
     * @param  {[type]} args     object that will be merged with the main configuration once worker is initialised
     * @param  {[type]} execArgv list of string arguments passed to the worker process
     */
    onWorkerStart: async function (cid, caps, specs, args, execArgv) {
        if ((process.argv.indexOf('--panel') != -1) || (process.argv.indexOf('--android') != -1)) {
            await require('kill-port')(this.port)
            await require('./utils/appiumHelper').AppiumHelper.start(this.port)
        }
    },
    /**
     * Gets executed just before initialising the webdriver session and test framework. It allows you
     * to manipulate configurations depending on the capability or spec.
     * @param {Object} config wdio configuration object
     * @param {Array.<Object>} capabilities list of capabilities details
     * @param {Array.<String>} specs List of spec file paths that are to be run
     * @param {String} cid worker id (e.g. 0-0)
     */
    // beforeSession: function (config, capabilities, specs, cid) {
    // },
    /**
     * Gets executed before test execution begins. At this point you can access to all global
     * variables like `browser`. It is the perfect place to define custom commands.
     * @param {Array.<Object>} capabilities list of capabilities details
     * @param {Array.<String>} specs        List of spec file paths that are to be run
     * @param {Object}         browser      instance of created browser/device session
     */
    before: async function (capabilities, specs) {
        await require('./utils/util').load()

        if (process.argv.indexOf('--panel') != -1) {
            const panelID = process.argv[process.argv.indexOf('--panel') + 1].toString().split(',')[0]
            let adb = await checkAdbIsOn(panelID)
            if (!adb) {
                await adbConnect(panelID)
            }
            try {
                await AppiumHelper.start()
            } catch (e) { }
            await require('./utils/appiumHelper').AppiumHelper.addPanelClient(this.port, panelID)
        }

        if (process.argv.indexOf('--android') != -1) {
            const androidID = process.argv[process.argv.indexOf('--android') + 1]
            await require('./utils/appiumHelper').AppiumHelper.addAndroidClient(this.port, androidID)
        }
    },
    /**
     * Runs before a WebdriverIO command gets executed.
     * @param {String} commandName hook command name
     * @param {Array} args arguments that command would receive
     */
    // beforeCommand: function (commandName, args) {
    // },
    /**
     * Cucumber Hooks
     *
     * Runs before a Cucumber Feature.
     * @param {String}                   uri      path to feature file
     * @param {GherkinDocument.IFeature} feature  Cucumber feature object
     */
    // beforeFeature: function (uri, feature) {
    // },
    /**
     *
     * Runs before a Cucumber Scenario.
     * @param {ITestCaseHookParameter} world    world object containing information on pickle and test step
     * @param {Object}                 context  Cucumber World object
     */
    beforeScenario: async function (world, context) {
        console.log("start execution:beforeScenario hook...")
        const tags = world.pickle.tags
        console.log("Number of case tags:" + tags.length)
        if (!(tags.length === 0)) {
            console.log("is include '@needMultiDevice' tag")
            for (const item of tags) {
                const tagText = item.name
                console.log("tag name:" + tagText)
                if (tagText.includes("needMultiDevice")) {
                    const panelIDs = await (process.argv[process.argv.indexOf('--panel') + 1].toString().split(','))
                    console.log("panels list:" + panelIDs)
                    let port = 4723
                    for (let i = 1; i < panelIDs.length; i++) {
                        console.log("panels[0]:" + panels.get(panelIDs[0]))
                        if ((!(panelIDs[i] === panelID)) && (!(panels.get(panelIDs[0]) === panelIDs[i]))) {
                            port = port + 2
                            console.log("use port:" + port)
                            await require('kill-port')(port)
                            await require('./utils/appiumHelper').AppiumHelper.start(port)
                            console.log("device:" + panelIDs[i] + "start connecting...")
                            let panelMessage = await require('./utils/appiumHelper').AppiumHelper.addPanelClient_2(port, panelIDs[i])
                            panels.set(panelIDs[i], panelMessage)
                        }
                    }
                }
            }
        }
    },
    /**
     *
     * Runs before a Cucumber Step.
     * @param {Pickle.IPickleStep} step     step data
     * @param {IPickle}            scenario scenario pickle
     * @param {Object}             context  Cucumber World object
     */
    // beforeStep: function (step, scenario, context) {
    // },
    /**
     *
     * Runs after a Cucumber Step.
     * @param {Pickle.IPickleStep} step             step data
     * @param {IPickle}            scenario         scenario pickle
     * @param {Object}             result           results object containing scenario results
     * @param {boolean}            result.passed    true if scenario has passed
     * @param {string}             result.error     error stack if scenario failed
     * @param {number}             result.duration  duration of scenario in milliseconds
     * @param {Object}             context          Cucumber World object
     */
    afterStep: async function (step, scenario, { error, duration, passed }, context) {
        if (error) {
            const { logcat } = require('./utils/adbHelper')
            await browser.takeScreenshot()
            const reporter = require('@wdio/allure-reporter').default
            if (global.panel) {
                const base64Data = await panel.takeScreenshot()
                const panelScreenshot = Buffer.from(base64Data, 'base64')
                reporter.addAttachment('panel-screenshot', panelScreenshot, '')
                const panelLog = logcat(panelID)
                reporter.addAttachment('panel-log', panelLog, 'text/plain')
            }
            if (global.android) {
                const base64Data = await android.takeScreenshot()
                const androidScreenshot = Buffer.from(base64Data, 'base64')
                reporter.addAttachment('android-screenshot', androidScreenshot, '')
                const androidLog = logcat(androidID)
                reporter.addAttachment('android-log', androidLog, 'text/plain')
            }
        }
    },
    /**
     *
     * Runs after a Cucumber Scenario.
     * @param {ITestCaseHookParameter} world            world object containing information on pickle and test step
     * @param {Object}                 result           results object containing scenario results
     * @param {boolean}                result.passed    true if scenario has passed
     * @param {string}                 result.error     error stack if scenario failed
     * @param {number}                 result.duration  duration of scenario in milliseconds
     * @param {Object}                 context          Cucumber World object
     */
    afterScenario: async function (world, result, context) {
        const { TestrailTool } = require('./utils/testrail-support')
        if (world.pickle.tags[0]) {
            world.pickle.tags.forEach(item => {
                const caseId = item.name.replace(/[^0-9]/ig, "")
                if (caseId) {
                    const comment = result.error ? result.error.split('\n')[0] : ''
                    TestrailTool.collectResult(caseId, result.passed, comment)
                }
            })
        }
    },
    /**
     *
     * Runs after a Cucumber Feature.
     * @param {String}                   uri      path to feature file
     * @param {GherkinDocument.IFeature} feature  Cucumber feature object
     */
    // afterFeature: function (uri, feature) {
    // },

    /**
     * Runs after a WebdriverIO command gets executed
     * @param {String} commandName hook command name
     * @param {Array} args arguments that command would receive
     * @param {Number} result 0 - command success, 1 - command error
     * @param {Object} error error object if any
     */
    // afterCommand: function (commandName, args, result, error) {
    // },
    /**
     * Gets executed after all tests are done. You still have access to all global variables from
     * the test.
     * @param {Number} result 0 - test pass, 1 - test fail
     * @param {Array.<Object>} capabilities list of capabilities details
     * @param {Array.<String>} specs List of spec file paths that ran
     */
    after: async function (result, capabilities, specs) {
        if (global.panel) {
            await panel.deleteSession()
        }

        if (global.android) {
            await android.deleteSession()
        }

        const { TestrailTool } = require('./utils/testrail-support')
        const TESTRAIL_CONFIG = {
            email: process.env.TESTRAIL_USERNAME,
            apiKey: process.env.TESTRAIL_PASSWORD_KEY,
            runId: process.env.TESTRAIL_RUN_ID,
            url: process.env.TESTRAIL_REST_URL
        }
        if (TESTRAIL_CONFIG.email) {
            await TestrailTool.uploadToTestrail(TESTRAIL_CONFIG)
        }
    },
    /**
     * Gets executed right after terminating the webdriver session.
     * @param {Object} config wdio configuration object
     * @param {Array.<Object>} capabilities list of capabilities details
     * @param {Array.<String>} specs List of spec file paths that ran
     */
    // afterSession: function (config, capabilities, specs) {    
    // },
    /**
     * Gets executed after all workers got shut down and the process is about to exit. An error
     * thrown in the onComplete hook will result in the test run failing.
     * @param {Object} exitCode 0 - success, 1 - fail
     * @param {Object} config wdio configuration object
     * @param {Array.<Object>} capabilities list of capabilities details
     * @param {<Object>} results object containing test results
     */
    onComplete: async function (exitCode, config, capabilities, results) {
        if ((process.argv.indexOf('--panel') != -1) || (process.argv.indexOf('--android') != -1)) {
            await require('kill-port')(this.port)
        }
    },
    /**
    * Gets executed when a refresh happens.
    * @param {String} oldSessionId session ID of the old session
    * @param {String} newSessionId session ID of the new session
    */
    //onReload: function(oldSessionId, newSessionId) {
    //}
}