quine-global/webdriverio.git

import fs from 'node:fs/promises'
import url from 'node:url'
import path from 'node:path'
import assert from 'node:assert'
import { expect } from 'expect-webdriverio'

import { SevereServiceError } from 'webdriverio'

const __dirname = path.dirname(url.fileURLToPath(import.meta.url))
const baseConfig = path.resolve(__dirname, 'helpers', 'config.js')
const parallelMultiRemoteBaseConfig = path.resolve(__dirname, 'helpers', 'parallel-multiremote-config.js')
const jasmineConfig = path.resolve(__dirname, 'helpers', 'configJasmine.js')
const allPassedConfig = path.resolve(__dirname, 'tests-cli-spec-arg/wdio-with-all-passed.conf.js')
const noArgConfig = path.resolve(__dirname, 'tests-cli-spec-arg/wdio-with-no-arg.conf.js')
const severalPassedConfig = path.resolve(__dirname, 'tests-cli-spec-arg/wdio-with-failed.conf.js')
const allPassedWildCardConfig = path.resolve(__dirname, 'tests-cli-spec-arg/wdio-with-all-passed-wildcard.conf.js')

// eslint-disable-next-line no-control-regex
const ansiColorRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g

process.env.WDIO_UNIT_TESTS = '1'

import launch from './helpers/launch.js'
import {
    SERVICE_LOGS,
    LAUNCHER_LOGS,
    REPORTER_LOGS,
    JASMINE_REPORTER_LOGS,
    CUCUMBER_REPORTER_LOGS,
} from './helpers/fixtures.js'

export const sleep = (ms = 0) => new Promise((r) => setTimeout(r, ms))

async function fileExists (path) {
    try {
        await fs.access(path)
        return true
    } catch {
        return false
    }
}

async function runTests (tests) {
    /**
     * Usage example: `npm run test:smoke -- customService`
     */
    const testFilter = process.argv[2]

    if (process.env.CI || testFilter) {
        const testsFiltered = testFilter ? tests.filter(test => test.name === testFilter) : tests

        if (testsFiltered.length === 0) {
            throw new Error(
                `No test was selected! Smoke test "${testFilter}" ` +
                `picked but only ${tests.map(test => test.name).join(', ')} available`
            )
        }

        // sequential
        for (const test of testsFiltered) {
            await test()
        }
    } else {
        // parallel
        await Promise.all(tests.map(test => test().catch((err) => {
            throw new Error(`Smoke test failed with name ${test.name}, ${err.stack}`)
        })))
    }
}

/**
 * Mocha wdio testrunner tests
 */
const mochaTestrunner = async () => {
    const { skippedSpecs, passed } = await launch('mochaTestrunner', baseConfig, {
        specs: [
            '../mocha/test.ts',
            path.resolve(__dirname, 'mocha', 'test-middleware.ts'),
            path.resolve(__dirname, 'mocha', 'test-waitForElement.ts'),
            path.resolve(__dirname, 'mocha', 'test-skipped.ts'),
            path.resolve(__dirname, 'mocha', 'cjs', 'test-cjs.js')
        ]
    })

    /**
     * assertion fails in Windows
     * ToDo(Christian): fix
     */
    if (process.platform === 'win32') {
        return
    }
    assert.strictEqual(skippedSpecs, 1)
    assert.strictEqual(passed, 4)
}

/**
 * Mocha wdio testrunner tests with asynchronous execution, also checks
 * if `spec` CLI arguments are relative to cwd
 */
const mochaAsyncTestrunner = async () => {
    const { skippedSpecs } = await launch(
        'mochaAsyncTestrunner',
        path.resolve(__dirname, 'helpers', 'command.hook.config.js'),
        {
            spec: ['./mocha/test-async.ts']
        }
    )
    assert.strictEqual(skippedSpecs, 0)
}

/**
 * Test if you can run CJS tests
 */
const cjsTestrunner = async () => {
    const { skippedSpecs } = await launch('cjsTestrunner', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'cjs', 'test-cjs.js')]
    })
    assert.strictEqual(skippedSpecs, 0)
}

/**
 * Jasmine wdio testrunner tests
 */
const jasmineTestrunner = async () => {
    const logFile = path.resolve(__dirname, 'helpers', 'expectationResults.log')
    await fs.rm(logFile, { force: true })
    const { skippedSpecs } = await launch('jasmineTestrunner', jasmineConfig, {
        specs: [
            path.resolve(__dirname, 'jasmine', 'test.js'),
            path.resolve(__dirname, 'jasmine', 'test-skipped.js')
        ],
        framework: 'jasmine'
    })
    /**
     * assertion fails in Windows
     * ToDo(Christian): fix
     */
    if (process.platform === 'win32') {
        return
    }

    assert.strictEqual(skippedSpecs, 1)
    expect((await fs.readFile(logFile, 'utf-8')).toString()).toBe(
        [
            'expect(number).toBe(number)',
            'expect(number).toBe(number)',
            'expect(number).toBe(number)',
            'expect(object).toEqual(object)',
            'expect(object).toBeFalse(boolean)',
            'expect(object).toHaveTitle(object)',
            'expect(object).toHaveTitle(object)',
            'expect(object).toHaveUrl(object)',
            'expect(object).toHaveUrl(object)',
            'expect(string).toHaveTitle(object)',
            'expect(object).toBeDisplayed(object)',
            'expect(object).toBeDisplayed(object)',
            'expect(number).toBe(number)',
            'expect(number).toBe(number)',
            'expect(object).toBeDefined(function)',
            'expect(function).toBeInstanceOf(function)',
            'expect(object).testMatcher(number)',
            'expect(string).toMatchInlineSnapshot(object)',
            ''
        ].join('\n')
    )
}

/**
 * Jasmine reporter
 */
const jasmineReporter = async () => {
    await launch('jasmineReporter', baseConfig, {
        specs: [path.resolve(__dirname, 'jasmine', 'reporter.js')],
        reporters: [['smoke-test', { foo: 'bar' }]],
        framework: 'jasmine',
        outputDir: __dirname + '/jasmine'
    }).catch((err) => err) // error expected
    await sleep(100)
    const reporterLogsPath = path.resolve(__dirname, 'jasmine', 'wdio-0-0-smoke-test-reporter.log')
    const reporterLogs = await fs.readFile(reporterLogsPath)
    expect(reporterLogs.toString()).toEqual(JASMINE_REPORTER_LOGS)
    await fs.unlink(reporterLogsPath)
}

/**
 * Jasmine timeout test
 */
const jasmineTimeout = async () => {
    const logFile = path.resolve(__dirname, 'jasmineTimeout.spec.log')
    await launch('jasmineTimeout', baseConfig, {
        specs: [path.resolve(__dirname, 'jasmine', 'test-timeout.js')],
        reporters: [
            ['spec', {
                outputDir: __dirname,
                stdout: false,
                logFile
            }]
        ],
        framework: 'jasmine'
    }).catch((err) => err) // error expected

    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    assert.ok(
        specLogs.includes('Error: Timeout - Async function did not complete within 1000ms (custom timeout)'),
        'spec was not failing due to timeout error'
    )
    assert.ok(
        specLogs.includes('at listOnTimeout (node:internal'),
        'spec was not failing a sync assertion error'
    )
    assert.ok(
        !specLogs.includes('RangeError: Maximum call stack size exceeded'),
        'spec was failing due to unexpected "Maximum call stack size exceeded"'
    )
    assert.ok(
        specLogs.includes('✓ should allow also async assertions afterwards'),
        'spec should also allow async assertions afterwards'
    )
}

/**
 * Jasmine afterAll is wrongly reported as a failing test - issue #8979
 * https://github.com/webdriverio/webdriverio/issues/8979
 */
const jasmineAfterAll = async () => {
    const logFile = path.resolve(__dirname, 'jasmineAfterAll.spec.log')
    await launch('jasmineAfterAll', baseConfig, {
        specs: [path.resolve(__dirname, 'jasmine', 'afterAll-report.js')],
        reporters: [
            ['spec', {
                outputDir: __dirname,
                stdout: false,
                logFile
            }]
        ],
        framework: 'jasmine'
    }).catch((err) => err) // error expected

    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')

    assert.ok(
        specLogs.includes('Testing after all hook'),
        'spec did not execute the expected describe'
    )
    assert.ok(
        specLogs.includes('actual expected') && specLogs.includes('truefalse'),
        'spec did not fail with the expected check'
    )
    assert.ok(
        specLogs.includes('✖ Should fail'),
        'spec did not fail on the expected test'
    )
    assert.ok(
        !specLogs.includes('✖ "after all" hook'),
        'spec reported the after all hook as a failed test'
    )
}

/**
 * Jasmine verify failSpecWithNoExpectations support
 */
const jasmineFailSpecWithNoExpectations = async () => {
    const logFile = path.resolve(__dirname, 'jasmineWithNoExpectations.spec.log')
    await launch('jasmineAfterAll', baseConfig, {
        specs: [path.resolve(__dirname, 'jasmine', 'jasmineWithNoExpectations.js')],
        reporters: [
            ['spec', {
                outputDir: __dirname,
                stdout: false,
                logFile
            }]
        ],
        framework: 'jasmine',
        jasmineOpts: {
            failSpecWithNoExpectations: true
        }
    }).catch((err) => err) // error expected

    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    assert.ok(
        specLogs.includes('No assertions found in test'),
        'spec did not fail with the expected check'
    )
}

/**
 * Cucumber wdio testrunner tests
 */
const cucumberTestrunner = async () => {
    const { skippedSpecs } = await launch(
        'cucumberTestrunner',
        path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
        {
            specs: [
                path.resolve(__dirname, 'cucumber', 'test.feature'),
                path.resolve(__dirname, 'cucumber', 'test-skipped.feature')
            ],
            cucumberOpts: {
                tags: '(not @SKIPPED_TAG)',
                ignoreUndefinedDefinitions: true,
                retry: 1,
                retryTagFilter: '@retry',
                scenarioLevelReporter: true
            }
        }
    )
    assert.strictEqual(skippedSpecs, 1)
}

/**
 * Cucumber wdio testrunner -- run single scenario by line number
 */
const cucumberTestrunnerByLineNumber = async () => {
    const logFile = path.resolve(__dirname, 'cucumber', 'cucumberTestrunnerByLineNumber.log')
    await fs.rm(logFile, { force: true })
    await launch(
        'cucumberTestrunnerByLineNumber',
        path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
        {
            spec: [path.resolve(__dirname, 'cucumber', 'test.feature:10')],
            cucumberOpts: {
                tags: '(not @SKIPPED_TAG)',
                scenarioLevelReporter: false
            },
            reporters: [
                ['spec', {
                    outputDir: __dirname,
                    stdout: false,
                    logFile
                }]]
        }
    )
    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    assert.ok(
        specLogs.includes('Sync Execution'),
        'scenario not executed in feature by line number'
    )
    assert.ok(
        !specLogs.includes('Retry Check'),
        'extra scenarios not filtered out by line number'
    )
}

/**
 * Cucumber wdio testrunner -- run three features (by line number) and verify each only runs once
 */
const cucumberTestrunnerMultipleByLineNumber = async () => {
    const featureDir = path.resolve(__dirname, 'cucumber', 'features')
    const { failed, passed, skippedSpecs } = await launch(
        'cucumberTestrunnerMultipleByLineNumber',
        path.resolve(__dirname, 'helpers', 'cucumber-features.conf.js'),
        {
            spec: [
                path.resolve(featureDir, 'test1.feature:4'),
                // deliberately w/o line number to capture more potential bugs
                path.resolve(featureDir, 'test2.feature'),
                path.resolve(featureDir, 'test3.feature:4'),
            ],
            reporters: [
                ['spec', {
                    outputDir: __dirname,
                    stdout: false,
                }]]
        }
    )
    assert.strictEqual(failed, 0)
    assert.strictEqual(passed, 3)
    assert.strictEqual(skippedSpecs, 0)
}

/**
 * Cucumber fail due to failAmbiguousDefinitions
 */
const cucumberFailAmbiguousDefinitions = async () => {
    const hasFailed = await launch(
        'cucumberFailAmbiguousDefinitions',
        path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
        {
            specs: [path.resolve(__dirname, 'cucumber', 'test.feature')],
            cucumberOpts: {
                ignoreUndefinedDefinitions: true,
                failAmbiguousDefinitions: true,
                name: ['failAmbiguousDefinitions']
            }
        }
    ).then(
        () => false,
        () => true
    )
    assert.equal(hasFailed, true)
}

/**
 * Cucumber pending status test
 */
const cucumberPendingTest = async () => {
    const logFile = path.resolve(__dirname, 'cucumber', 'cucumberPendingTest.log')
    await fs.rm(logFile, { force: true })

    await launch(
        'cucumberPendingTest',
        path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
        {
            specs: [
                path.resolve(__dirname, 'cucumber', 'test-pending.feature')
            ],
            reporters: [
                ['spec', {
                    outputDir: __dirname,
                    stdout: false,
                    logFile
                }]
            ],
            cucumberOpts: {
                ignoreUndefinedDefinitions: true,
                scenarioLevelReporter: true
            }
        }
    )

    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    const pendingMatch = specLogs.match(/(\d+)\s+pending/)
    assert.ok(
        pendingMatch && parseInt(pendingMatch[1], 10) === 1,
        'Expected exactly 1 pending test in output'
    )
}

/**
 * Cucumber reporter
 */
const cucumberReporter = async () => {
    const basePath = path.resolve(__dirname, 'cucumber', 'reporter')
    await launch(
        'cucumberReporter',
        path.resolve(basePath, 'reporter.config.js'),
        {
            specs: [path.resolve(basePath, 'reporter.feature')],
            outputDir: basePath,
        }
    ).catch((err) => err) // error expected
    await sleep(100)
    const reporterLogsPath = path.join(basePath, 'wdio-0-0-smoke-test-reporter.log')
    const reporterLogs = await fs.readFile(reporterLogsPath)
    assert.equal(reporterLogs.toString(), CUCUMBER_REPORTER_LOGS)
    await fs.unlink(reporterLogsPath)
}

/**
 * Cucumber file option
 */
const cucumberFileOption = async () => {
    const logFile = path.resolve(__dirname, 'cucumber', 'cucumberFileOption.log')
    await fs.rm(logFile, { force: true })
    const { passed } = await launch(
        'cucumberFileOption',
        path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
        {
            specs: [
                path.resolve(__dirname, 'cucumber', 'test.feature'),
            ],
            reporters: [
                ['spec', {
                    outputDir: __dirname,
                    stdout: false,
                    logFile
                }]],
            cucumberOpts: {
                ignoreUndefinedDefinitions: true,
                scenarioLevelReporter: true,
                retry: 1,
                retryTagFilter: '@retry',
                file: './cucumber/cucumber.js'
            }
        }
    )
    assert.strictEqual(passed, 1)
    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    assert.ok(
        specLogs.includes('test-skipped.feature'),
        'scenario not included according to cucumber config'
    )
}

/**
 * Cucumber @skip() tag
 */
const cucumberSkipTag = async () => {
    for (const browserName of ['chrome', 'firefox']) {
        const { skippedSpecs } = await launch(
            'cucumberTestrunner',
            path.resolve(__dirname, 'helpers', 'cucumber-hooks.conf.js'),
            {
                capabilities: [{ browserName }],
                specs: [
                    path.resolve(__dirname, 'cucumber', 'test.feature'),
                    path.resolve(__dirname, 'cucumber', 'test-skipped.feature')
                ],
                cucumberOpts: {
                    tags: '(not @SKIPPED_TAG)',
                    ignoreUndefinedDefinitions: true,
                    retry: 1,
                    retryTagFilter: '@retry',
                    scenarioLevelReporter: true
                }
            }
        )
        assert.strictEqual(skippedSpecs, 1)
    }
}

/**
 * wdio test run with custom service
 */
const customService = async () => {
    await launch('customService', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'service.js')],
        services: [['smoke-test', { foo: 'bar' }]]
    })
    await sleep(100)
    const serviceLogs = await fs.readFile(path.resolve(__dirname, 'helpers', 'service.log'))
    assert.equal(serviceLogs.toString(), SERVICE_LOGS)
    const launcherLogs = await fs.readFile(path.resolve(__dirname, 'helpers', 'launcher.log'))
    assert.equal(launcherLogs.toString(), LAUNCHER_LOGS)
}

/**
 * wdio test run with custom service
 */
const customCJSService = async () => {
    await launch('customCJSService', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'service.js')],
        services: [['smoke-test-cjs', { foo: 'bar' }]]
    })
    await sleep(100)
    const serviceLogs = await fs.readFile(path.resolve(__dirname, 'helpers', 'service.log'))
    assert.equal(serviceLogs.toString(), SERVICE_LOGS)
    const launcherLogs = await fs.readFile(path.resolve(__dirname, 'helpers', 'launcher.log'))
    assert.equal(launcherLogs.toString(), LAUNCHER_LOGS)
}

/**
 * wdio test run with custom reporter as string
 */
const customReporterString = async () => {
    await launch('customReporterString', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'reporter.js')],
        reporters: [['smoke-test', { foo: 'bar' }]]
    })
    await sleep(100)
    const reporterLogsPath = path.resolve(__dirname, 'helpers', 'wdio-0-0-smoke-test-reporter.log')
    const reporterLogs = await fs.readFile(reporterLogsPath)
    assert.equal(reporterLogs.toString(), REPORTER_LOGS)
    await fs.unlink(reporterLogsPath)
}

/**
 * wdio test run with custom reporter as object
 */
const customReporterObject = async () => {
    await launch(
        'customReporterObject',
        path.resolve(__dirname, 'helpers', 'reporter.conf.js'),
    )
    await sleep(100)
    const reporterLogsWithReporterAsObjectPath = path.resolve(__dirname, 'helpers', 'wdio-0-0-CustomSmokeTestReporter-reporter.log')
    const reporterLogsWithReporterAsObject = await fs.readFile(reporterLogsWithReporterAsObjectPath)
    assert.equal(reporterLogsWithReporterAsObject.toString(), REPORTER_LOGS)
    await fs.unlink(reporterLogsWithReporterAsObjectPath)
}

/**
 * wdio-reporter testrunner tests
 */
const reporterTestrunner = async () => {
    const { skippedSpecs, passed, failed } = await launch('reporterTestrunner', baseConfig, {
        specs: [
            path.resolve(__dirname, 'reporter', 'memory.ts'),
        ]
    })
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(passed, 1)
    assert.strictEqual(failed, 0)
}

/**
 * wdio test run with before/after Test/Hook
 */
const wdioHooks = async () => {
    await launch(
        'wdioHooks',
        path.resolve(__dirname, 'helpers', 'hooks.conf.js'),
        {
            specs: [path.resolve(__dirname, 'mocha', 'wdio_hooks.js')]
        }
    )
}

/**
 * multiremote wdio testrunner tests
 */
const multiremote = async () => {
    await launch('multiremote', baseConfig, {
        specs: [path.resolve(__dirname, 'multiremote', 'test.js')],
        capabilities: {
            browserA: {
                capabilities: { browserName: 'chrome' }
            },
            browserB: {
                capabilities: { browserName: 'chrome' }
            }
        }
    })

    const { skippedSpecs, passed, failed } = await launch('multiremote', baseConfig, {
        specs: [
            path.resolve(__dirname, 'multiremote', 'test-filter1.js'),
            path.resolve(__dirname, 'multiremote', 'test-filter2.js')
        ],
        capabilities: {
            browserA: {
                capabilities: { browserName: 'chrome',  }
            },
            browserB: {
                capabilities: {
                    browserName: 'chrome',
                    'wdio:exclude': [
                        path.resolve(__dirname, 'multiremote', 'test-filter2.js')
                    ]
                }
            }
        }
    })
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(passed, 2)
    assert.strictEqual(failed, 0)
}

/**
 * parallel multiremote wdio testrunner tests
 */
const parallelMultiremote = async () => {
    console.log(parallelMultiRemoteBaseConfig)
    await launch('parallelMultiremote', parallelMultiRemoteBaseConfig, {
        specs: [path.resolve(__dirname, 'multiremote', 'test.js')],
    })
}

/**
 * specfile-level retries (fail)
 */
const retryFail = async () => {
    const retryFailed = await launch('retryFailed', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'retry_and_fail.js')],
        specFileRetries: 1
    }).then(
        () => false,
        () => true
    )
    assert.equal(retryFailed, true, 'Expected retries to fail but they passed')
}

/**
 * specfile-level retries (pass)
 */
const retryPass = async () => {
    const retryFilename = path.resolve(__dirname, '.retry_succeeded')
    const logfiles = ['wdio-0-0.log', 'wdio-0-1.log'].map(f => path.join(__dirname, f))
    const rmfiles = [retryFilename, ...logfiles]
    for (const filename of rmfiles) {
        if (await fileExists(filename)) {
            fs.unlink(filename, err => {
                if (err) {
                    throw Error(`Unable to delete ${filename}`)
                }
            })
        }
    }
    await launch('retryPass', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'retry_and_pass.js')],
        outputDir: path.dirname(logfiles[0]),
        specFileRetries: 1,
        specFileRetriesDelay: 1,
        retryFilename
    })

    if (!await fileExists(logfiles[0])) {
        throw Error(`Expected ${logfiles[0]} to exist but it does not`)
    }
    if (await fileExists(logfiles[1])) {
        throw Error(`Expected ${logfiles[1]} to not exist but it does`)
    }
}

/**
 * wdio-shared-store-service tests
 */
const sharedStoreServiceTest = async () => {
    /**
     * assertion fails in Windows
     * ToDo(Christian): fix
     */
    if (process.platform === 'win32') {
        return
    }
    await launch(
        'sharedStoreServiceTest',
        path.resolve(__dirname, 'helpers', 'shared-store.conf.js'),
        {
            specs: [path.resolve(__dirname, 'mocha', 'shared-store-service.js')]
        }
    )
}

/**
 * Mocha with specFiltering feature enabled
 */
const mochaSpecFiltering = async () => {
    const { skippedSpecs } = await launch('mochaSpecFiltering', baseConfig, {
        specs: [
            path.resolve(__dirname, 'mocha', 'test-empty.js'),
            path.resolve(__dirname, 'mocha', 'test-skipped.ts'),
            path.resolve(__dirname, 'mocha', 'test-skipped-grep.js')
        ]
    })
    assert.strictEqual(skippedSpecs, 2)
}

/**
 * Jasmine with specFiltering feature enabled
 */
const jasmineSpecFiltering = async () => {
    const { skippedSpecs } = await launch('jasmineSpecFiltering', baseConfig, {
        specs: [
            path.resolve(__dirname, 'jasmine', 'test-empty.js'),
            path.resolve(__dirname, 'jasmine', 'test-skipped.js'),
            path.resolve(__dirname, 'jasmine', 'test-skipped-grep.js')
        ],
        framework: 'jasmine'
    })
    assert.strictEqual(skippedSpecs, 2)
}

/**
 * Mocha with spec grouping feature enabled
 */
const mochaSpecGrouping = async () => {
    const { skippedSpecs } = await launch('mochaSpecGrouping', baseConfig, {
        specs: [
            [
                path.resolve(__dirname, 'mocha', 'test-empty.js'),
                path.resolve(__dirname, 'mocha', 'test-middleware.js'),
                path.resolve(__dirname, 'mocha', 'test-waitForElement.js'),
                path.resolve(__dirname, 'mocha', 'test-skipped.js'),
                path.resolve(__dirname, 'mocha', 'test-skipped-grep.js')
            ]
        ]
    })
    // Specs will be treated as a group, so no specs will be skipped
    assert.strictEqual(skippedSpecs, 0)
}

/**
 * Mocha wdio testrunner tests
 */
const standaloneTest = async () => {
    const { skippedSpecs } = await launch(
        'standaloneTest',
        path.resolve(__dirname, 'helpers', 'async.config.js'),
        {
            specs: [path.resolve(__dirname, 'mocha', 'standalone.js')]
        }
    )
    assert.strictEqual(skippedSpecs, 0)
}

const severeErrorTest = async () => {
    const onPrepareFailed = await launch('severeErrorTest - onPrepareFailed', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'test-empty.js')],
        onPrepare: () => { throw new SevereServiceError('ups') }
    }).then(() => false, () => true)
    assert.equal(onPrepareFailed, true, 'Expected onPrepare to fail testrun')

    const onWorkerStartFailed = await launch('severeErrorTest - onWorkerStartFailed', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'test-empty.js')],
        onWorkerStart: () => { throw new SevereServiceError('ups') }
    }).then(() => false, () => true)
    assert.equal(onWorkerStartFailed, true, 'Expected onWorkerStart to fail testrun')

    const onWorkerEndFailed = await launch('severeErrorTest - onWorkerEndFailed', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'test-empty.js')],
        onWorkerEnd: () => { throw new SevereServiceError('ups') }
    }).then(() => false, () => true)
    assert.equal(onWorkerEndFailed, true, 'Expected onWorkerStart to fail testrun')

    const onCompleteFailed = await launch('severeErrorTest - onCompleteFailed', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'test-empty.js')],
        onComplete: () => { throw new SevereServiceError('ups') }
    }).then(() => false, () => true)
    assert.equal(onCompleteFailed, true, 'Expected onWorkerStart to fail testrun')
}

/**
 * test usage of globals package
 */
const nonGlobalTestrunner = async () => {
    const hasFailed = await launch('nonGlobalTestrunner', baseConfig, {
        specs: [path.resolve(__dirname, 'mocha', 'noGlobals.ts')],
        injectGlobals: false
    }).then(() => false, () => true)
    assert.strictEqual(hasFailed, false)
}

/**
 * Mocha wdio testrunner skip tests via wdio hook
 */
const mochaHooksTestrunner = async () => {
    const { skippedSpecs } = await launch(
        'mochaHooksTestrunner',
        path.resolve(__dirname, 'helpers', 'mocha-hooks.conf.js'),
        {
            specs: [
                path.resolve(__dirname, 'mocha', 'test-skipped-hooks.ts'),
            ]
        }
    )
    assert.strictEqual(skippedSpecs, 0)
}

// ****************************
// *** Tests for CLI --spec ***
// ****************************
const runSpecsWithFlagAllPassed = async () => {
    const { passed, skippedSpecs } = await launch(
        'runSpecsWithFlagAllPassed',
        path.resolve(allPassedConfig),
        {
            spec: ['test']
        }
    )
    assert.strictEqual(passed, 4)
    assert.strictEqual(skippedSpecs, 0)
}

const runSpecsWithFlagSeveralPassed = async () => {
    const { passed, skippedSpecs } = await launch(
        'runSpecsWithFlagSeveralPassed',
        path.resolve(severalPassedConfig),
        {
            spec: ['mocha']
        }
    )
    assert.strictEqual(passed, 4)
    assert.strictEqual(skippedSpecs, 0)
}

const runSpecsWithFlagDirectPath = async () => {
    const { passed, skippedSpecs } = await launch(
        'runSpecsWithFlagDirectPath',
        path.resolve(severalPassedConfig),
        {
            spec: ['./tests-cli-spec-arg/mocha.test03.js']
        }
    )
    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
}

const runSpecsWithFlagNoArg = async () => {
    const { passed, skippedSpecs } = await launch(
        'runSpecsWithFlagNoArg',
        path.resolve(noArgConfig),
        {
            spec: []
        }
    )
    assert.strictEqual(passed, 3)
    assert.strictEqual(skippedSpecs, 0)
}

const cliExcludeParamValidationAllExcludedByKeyword = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationAllExcludedByKeyword',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.conf.js'),
        {
            exclude: ['general']
        }
    ).catch((err) => err) // expected error

    assert.strictEqual(passed, undefined)
    assert.strictEqual(skippedSpecs, undefined)
    assert.strictEqual(failed, undefined)
}

const cliExcludeParamValidationSomeExcludedByKeyword = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationSomeExcludedByKeyword',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.conf.js'),
        {
            exclude: ['general2']
        }
    )

    assert.strictEqual(passed, 2)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeParamValidationSomeExcludedByPath = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationSomeExcludedByPath',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.conf.js'),
        {
            exclude: ['./general.test.js']
        }
    )

    assert.strictEqual(passed, 2)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeParamValidationExcludeNonExistentByKeyword = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationExcludeNonExistentByKeyword',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.conf.js'),
        {
            exclude: ['newgeneral']
        }
    )

    assert.strictEqual(passed, 3)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeParamValidationExcludeFromConfigByKeyword = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationExcludeFromConfigByKeyword',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.with-exclude-prop.conf.js')
    )

    assert.strictEqual(passed, 2)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeParamValidationExcludeMultipleSpecsByPath = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeParamValidationExcludeMultipleSpecsByPath',
        path.resolve(__dirname, 'tests-cli-exclude-arg/wdio.conf.js'),
        {
            exclude: [
                './general.test.js',
                './general2.test.js'
            ]
        }
    )

    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliSpecsWithWildCard = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliSpecsWithWildCard',
        path.resolve(severalPassedConfig),
        {
            spec: ['mocha.test01*.js']
        }
    )
    assert.strictEqual(passed, 2)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliSpecsTheSameWithWildCard = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliSpecsTheSameWithWildCard',
        path.resolve(severalPassedConfig),
        {
            spec: [
                'mocha.test01*.js',
                'mocha.test01*.js'
            ]
        }
    )
    assert.strictEqual(passed, 2)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliSpecsWithWildCardAndGroup = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliSpecsWithWildCardAndGroup',
        path.resolve(severalPassedConfig),
        {
            spec: ['mocha.test01*.js'],
            group: true
        }
    )
    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeCertainWithWildCard = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeCertainWithWildCard',
        path.resolve(severalPassedConfig),
        {
            spec: ['mocha.test01*.js'],
            exclude: [
                'mocha.test01.js',
            ]
        }
    )
    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeSomeFromConfWithWildCard = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeSomeFromConfWithWildCard',
        path.resolve(allPassedWildCardConfig),
        {
            exclude: ['mocha.test01*.js'],
        }
    )
    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeSomeFromConfWithWildCardAndGroup = async () => {
    const { passed, skippedSpecs, failed } = await launch(
        'cliExcludeSomeFromConfWithWildCardAndGroup',
        path.resolve(allPassedWildCardConfig),
        {
            exclude: ['mocha.test01*.js'],
            group: true
        }
    )
    assert.strictEqual(passed, 1)
    assert.strictEqual(skippedSpecs, 0)
    assert.strictEqual(failed, 0)
}

const cliExcludeAllWithWildCard = async () => {
    try {
        await launch(
            'cliExcludeAllWithWildCard',
            path.resolve(allPassedWildCardConfig),
            {
                spec: ['mocha.test*.js'],
                exclude: ['mocha.test*.js'],
            }
        )
        assert.ok(false)
    } catch {
        assert.ok(true)
    }
}
// *** END - tests for CLI --spec ***

// *************************
// *** Tests for Jasmine ***
// *************************
const jasmineHooksTestrunner = async () => {
    const logFile = path.resolve(__dirname, 'jasmineHooksTestrunner.spec.log')
    await launch('jasmineHooksTestrunner',
        path.resolve(__dirname, 'helpers', 'jasmine-hooks.conf.js'),
        {
            specs: [path.resolve(__dirname, 'jasmine', 'test-skipped-hooks.ts')],
            reporters: [
                ['spec', {
                    outputDir: __dirname,
                    stdout: false,
                    logFile
                }]
            ],
            framework: 'jasmine',
        }).catch((err) => err) // error expected

    const specLogs = (await fs.readFile(logFile)).toString().replace(ansiColorRegex, '')
    assert.ok(
        specLogs.includes('skip test'),
    )
}

const jasmineAfterHookArgsValidation = async () => {
    const expectedPassedTestResultPath = path.resolve(__dirname, 'helpers', 'jasmine-after-hook-validation', 'expected-results', 'expectedTestPassed.json')
    const expectedFailedTestResultPath = path.resolve(__dirname, 'helpers', 'jasmine-after-hook-validation', 'expected-results', 'expectedTestFailed.json')

    // Actual test results are written to files in tests\helpers\jasmine.after-hook-validation.conf.js - afterTest()
    const actualPassedTestResultPath = path.resolve(__dirname, 'helpers', 'actualResultsPassed.log')
    const actualFailedTestResultPath = path.resolve(__dirname, 'helpers', 'actualResultsFailed.log')

    await launch('jasmineAfterHookArgsValidation',
        path.resolve(__dirname, 'helpers', 'jasmine.after-hook-validation.conf.js'),
        {
            specs: [
                path.resolve(__dirname, 'jasmine', 'test.after-hook-validation.ts')
            ]
        }).catch((err) => err) // error expected

    const actualPassedTestLogs = JSON.parse((await fs.readFile(actualPassedTestResultPath)))
    const actualFailedTestLogs = JSON.parse((await fs.readFile(actualFailedTestResultPath)))
    const expectedPassedTestLogs = JSON.parse((await fs.readFile(expectedPassedTestResultPath)))
    const expectedFailedTestLogs = JSON.parse((await fs.readFile(expectedFailedTestResultPath)))

    // Check before removing
    assert.equal(typeof actualPassedTestLogs.test.start, 'number')
    assert.equal(typeof actualPassedTestLogs.result.start, 'number')
    assert.equal(typeof actualPassedTestLogs.duration, 'number')
    assert.equal(typeof actualFailedTestLogs.test.start, 'number')
    assert.equal(typeof actualFailedTestLogs.duration, 'number')
    assert.equal(typeof actualFailedTestLogs.test.failedExpectations[0].stack, 'string')
    assert.equal(typeof actualFailedTestLogs.result.failedExpectations[0].stack, 'string')
    assert.equal(typeof actualFailedTestLogs.result.start, 'number')
    assert.equal(typeof actualFailedTestLogs.error.stack, 'string')

    // Remove dynamic values that will be different every time you run tests, e.g. start time or filepaths
    delete actualPassedTestLogs.test.start
    delete actualPassedTestLogs.test.filename
    delete actualPassedTestLogs.test.file
    delete actualPassedTestLogs.result.start
    delete actualPassedTestLogs.result.filename
    delete actualPassedTestLogs.result.file
    delete actualPassedTestLogs.duration
    delete actualFailedTestLogs.test.start
    delete actualFailedTestLogs.test.filename
    delete actualFailedTestLogs.test.file
    delete actualFailedTestLogs.test.failedExpectations[0].stack
    delete actualFailedTestLogs.error.stack
    delete actualFailedTestLogs.result.start
    delete actualFailedTestLogs.result.filename
    delete actualFailedTestLogs.result.file
    delete actualFailedTestLogs.result.failedExpectations[0].stack
    delete actualFailedTestLogs.duration

    assert.deepStrictEqual(actualPassedTestLogs, expectedPassedTestLogs)
    assert.deepStrictEqual(actualFailedTestLogs, expectedFailedTestLogs)
}
// *** END - Tests for Jasmine ***

(async () => {
    const smokeTests = [
        mochaTestrunner,
        jasmineTestrunner,
        multiremote,
        parallelMultiremote,
        wdioHooks,
        cjsTestrunner,
        sharedStoreServiceTest,
        mochaSpecGrouping,
        cucumberTestrunner,
        cucumberTestrunnerByLineNumber,
        cucumberTestrunnerMultipleByLineNumber,
        cucumberFailAmbiguousDefinitions,
        cucumberPendingTest,
        cucumberReporter,
        cucumberFileOption,
        cucumberSkipTag,
        standaloneTest,
        mochaAsyncTestrunner,
        customService,
        customCJSService,
        mochaSpecFiltering,
        jasmineSpecFiltering,
        jasmineReporter,
        jasmineTimeout,
        jasmineAfterAll,
        jasmineFailSpecWithNoExpectations,
        retryFail,
        retryPass,
        customReporterString,
        customReporterObject,
        reporterTestrunner,
        severeErrorTest,
        nonGlobalTestrunner,
        mochaHooksTestrunner,
        runSpecsWithFlagAllPassed,
        runSpecsWithFlagSeveralPassed,
        runSpecsWithFlagDirectPath,
        runSpecsWithFlagNoArg,
        jasmineHooksTestrunner,
        jasmineAfterHookArgsValidation,
        cliExcludeParamValidationAllExcludedByKeyword,
        cliExcludeParamValidationSomeExcludedByKeyword,
        cliExcludeParamValidationSomeExcludedByPath,
        cliExcludeParamValidationExcludeNonExistentByKeyword,
        cliExcludeParamValidationExcludeFromConfigByKeyword,
        cliExcludeParamValidationExcludeMultipleSpecsByPath,
        cliSpecsWithWildCard,
        cliSpecsTheSameWithWildCard,
        cliSpecsWithWildCardAndGroup,
        cliExcludeCertainWithWildCard,
        cliExcludeSomeFromConfWithWildCard,
        cliExcludeSomeFromConfWithWildCardAndGroup,
        cliExcludeAllWithWildCard
    ]

    console.log('\nRunning smoke tests...\n')
    await runTests(smokeTests)

    console.log('\nAll smoke tests passed!\n')
    process.exit(0)
})().catch((e) => {
    console.log(e.stack)

    process.exit(1)
})