codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/plugin/selenoid.js

@@ -1,384 +0,0 @@
-const util = require('util')
-const path = require('path')
-const fs = require('fs')
-const axios = require('axios').default
-const exec = util.promisify(require('child_process').exec)
-const { clearString, deepMerge } = require('../utils')
-const { container, event, recorder, output } = require('../index')
-
-const defaultBrowserConfig = {
-  chrome: {
-    default: 'latest',
-    versions: {
-      latest: {
-        image: 'selenoid/chrome:latest',
-        port: '4444',
-        path: '/',
-      },
-    },
-  },
-  firefox: {
-    default: 'latest',
-    versions: {
-      latest: {
-        image: 'selenoid/firefox:latest',
-        port: '4444',
-        path: '/wd/hub',
-      },
-    },
-  },
-}
-
-const dockerCreateScriptArr = [
-  'docker create --rm --name $name$',
-  '-p $port$:4444',
-  '-v /var/run/docker.sock:/var/run/docker.sock',
-  `-v ${global.codecept_dir}/:/etc/selenoid/:ro`,
-  `-v ${global.output_dir}/video/:/opt/selenoid/video/`,
-  `-v ${global.output_dir}/logs/:/opt/selenoid/logs/`,
-  `-e OVERRIDE_VIDEO_OUTPUT_DIR=${global.output_dir}/video/`,
-  '$additionalParams$',
-  'aerokube/selenoid:latest-release -log-output-dir /opt/selenoid/logs',
-]
-
-const dockerImageCheckScript = [
-  'docker images',
-  "--filter reference='selenoid/video-recorder'",
-  "--filter reference='selenoid/chrome:latest'",
-  "--filter reference='selenoid/firefox:latest'",
-].join(' ')
-
-let dockerCreateScript = dockerCreateScriptArr.join(' ')
-let dockerStartScript = 'docker start $name$'
-let dockerStopScript = 'docker stop $name$'
-let seleniumUrl = 'http://localhost:$port$'
-
-const supportedHelpers = ['WebDriver']
-const SELENOID_START_TIMEOUT = 2000
-const SELENOID_STOP_TIMEOUT = 10000
-const wait = (time) =>
-  new Promise((res) => {
-    setTimeout(() => {
-      // @ts-ignore
-      res()
-    }, time)
-  })
-
-/**
- * [Selenoid](https://aerokube.com/selenoid/) plugin automatically starts browsers and video recording.
- * Works with WebDriver helper.
- *
- * ### Prerequisite
- *
- * This plugin **requires Docker** to be installed.
- *
- * > If you have issues starting Selenoid with this plugin consider using the official [Configuration Manager](https://aerokube.com/cm/latest/) tool from Selenoid
- *
- * ### Usage
- *
- * Selenoid plugin can be started in two ways:
- *
- * 1. **Automatic** - this plugin will create and manage selenoid container for you.
- * 2. **Manual** - you create the conatainer and configure it with a plugin (recommended).
- *
- * #### Automatic
- *
- * If you are new to Selenoid and you want plug and play setup use automatic mode.
- *
- * Add plugin configuration in `codecept.conf.js`:
- *
- * ```js
- * plugins: {
- *     selenoid: {
- *       enabled: true,
- *       deletePassed: true,
- *       autoCreate: true,
- *       autoStart: true,
- *       sessionTimeout: '30m',
- *       enableVideo: true,
- *       enableLog: true,
- *     },
- *   }
- * ```
- *
- * When `autoCreate` is enabled it will pull the [latest Selenoid from DockerHub](https://hub.docker.com/u/selenoid) and start Selenoid automatically.
- * It will also create `browsers.json` file required by Selenoid.
- *
- * In automatic mode the latest version of browser will be used for tests. It is recommended to specify exact version of each browser inside `browsers.json` file.
- *
- * > **If you are using Windows machine or if `autoCreate` does not work properly, create container manually**
- *
- * #### Manual
- *
- * While this plugin can create containers for you for better control it is recommended to create and launch containers manually.
- * This is especially useful for Continous Integration server as you can configure scaling for Selenoid containers.
- *
- * > Use [Selenoid Configuration Manager](https://aerokube.com/cm/latest/) to create and start containers semi-automatically.
- *
- * 1. Create `browsers.json` file in the same directory `codecept.conf.js` is located
- * [Refer to Selenoid documentation](https://aerokube.com/selenoid/latest/#_prepare_configuration) to know more about browsers.json.
- *
- * *Sample browsers.json*
- *
- * ```js
- * {
- *  "chrome": {
- *    "default": "latest",
- *    "versions": {
- *      "latest": {
- *        "image": "selenoid/chrome:latest",
- *        "port": "4444",
- *        "path": "/"
- *      }
- *    }
- *  }
- * }
- * ```
- *
- * > It is recommended to use specific versions of browsers in `browsers.json` instead of latest. This will prevent tests fail when browsers will be updated.
- *
- * **⚠ At first launch selenoid plugin takes extra time to download all Docker images before tests starts**.
- *
- * 2. Create Selenoid container
- *
- * Run the following command to create a container. To know more [refer here](https://aerokube.com/selenoid/latest/#_option_2_start_selenoid_container)
- *
- *
- * ```bash
- * docker create                                    \
- * --name selenoid                                  \
- * -p 4444:4444                                     \
- * -v /var/run/docker.sock:/var/run/docker.sock     \
- * -v `pwd`/:/etc/selenoid/:ro                      \
- * -v `pwd`/output/video/:/opt/selenoid/video/      \
- * -e OVERRIDE_VIDEO_OUTPUT_DIR=`pwd`/output/video/ \
- * aerokube/selenoid:latest-release
- * ```
- *
- * ### Video Recording
- *
- * This plugin allows to record and save video per each executed tests.
- *
- * When `enableVideo` is `true` this plugin saves video in `output/videos` directory with each test by name
- * To save space videos for all succesful tests are deleted. This can be changed by `deletePassed` option.
- *
- * When `allure` plugin is enabled a video is attached to report automatically.
- *
- * ### Options:
- *
- * | Param | Description |
- * |--|--|
- * | name | Name of the container (default : selenoid) |
- * | port | Port of selenium server (default : 4444) |
- * | autoCreate | Will automatically create container (Linux only) (default : true)|
- * | autoStart | If disabled start the container manually before running tests (default : true)|
- * | enableVideo | Enable video recording and use `video` folder of output (default: false) |
- * | enableLog | Enable log recording and use `logs` folder of output (default: false) |
- * | deletePassed | Delete video and logs of passed tests (default : true)|
- * | additionalParams | example: `additionalParams: '--env TEST=test'` [Refer here](https://docs.docker.com/engine/reference/commandline/create/) to know more |
- *
- */
-
-const selenoid = (config) => {
-  const helpers = container.helpers()
-  let helperName
-
-  for (const name of supportedHelpers) {
-    if (Object.keys(helpers).indexOf(name) > -1) {
-      helperName = name
-    }
-  }
-
-  if (!helperName) {
-    output.print(`Selenoid plugin supported only for: ${supportedHelpers.toString()}`)
-    return // no helpers for Selenoid
-  }
-
-  const {
-    autoStart,
-    name = 'selenoid',
-    deletePassed = true,
-    additionalParams = '',
-    autoCreate = true,
-    port = 4444,
-  } = config
-  const passedTests = []
-
-  recorder.startUnlessRunning()
-  replaceScriptConfig({ name, additionalParams, port })
-
-  if (autoStart) {
-    event.dispatcher.on(event.all.before, () => {
-      recorder.add('Starting selenoid', () => {
-        output.debug('Staring Selenoid... ')
-        return createAndStart(autoCreate)
-          .then(() => output.debug('Selenoid started'))
-          .catch((err) => {
-            throw new Error(err.stack)
-          })
-      })
-    })
-
-    event.dispatcher.on(event.all.after, () => {
-      recorder.add('Stopping selenoid', () => {
-        output.debug('Stopping Selenoid...')
-        return wait(SELENOID_STOP_TIMEOUT)
-          .then(() => deletePassedTests(passedTests))
-          .then(stopSelenoid)
-          .then(() => output.debug('Selenoid stopped'))
-          .catch((err) => {
-            throw new Error(err.stack)
-          })
-      })
-    })
-  }
-
-  event.dispatcher.on(event.all.before, () => {
-    switch (helperName) {
-      case 'WebDriver':
-        setOptionsForWebdriver(config)
-        break
-    }
-  })
-
-  event.dispatcher.on(event.test.before, (test) => {
-    switch (helperName) {
-      case 'WebDriver':
-        setTestConfigForWebdriver(test)
-        break
-    }
-  })
-
-  if (config.enableVideo) {
-    event.dispatcher.on(event.test.passed, (test) => {
-      if (deletePassed) {
-        passedTests.push(test.title)
-      } else {
-        test.artifacts.video = videoSaved(test)
-      }
-    })
-
-    event.dispatcher.on(event.test.failed, (test) => {
-      test.artifacts.video = videoSaved(test)
-    })
-  }
-}
-
-module.exports = selenoid
-
-function videoSaved(test) {
-  const fileName = `${clearString(test.title)}.mp4`
-  const videoFile = path.join(global.output_dir, 'video', fileName)
-  output.debug(`Video has been saved to file://${videoFile}`)
-  const allureReporter = container.plugins('allure')
-  if (allureReporter) {
-    allureReporter.addAttachment('Video', fs.readFileSync(videoFile), 'video/mp4')
-  }
-  return videoFile
-}
-
-const createSelenoidConfig = () => {
-  const configPath = path.join(global.codecept_dir, 'browsers.json')
-  return new Promise((res, rej) => {
-    try {
-      if (fs.existsSync(configPath)) {
-        res(true)
-      } else {
-        const data = new Uint8Array(Buffer.from(JSON.stringify(defaultBrowserConfig)))
-        fs.writeFileSync(configPath, data)
-        res(true)
-      }
-    } catch (err) {
-      rej(err.stack)
-    }
-  })
-}
-
-const createSelenoid = () => exec(dockerCreateScript)
-
-const startSelenoid = () => exec(dockerStartScript)
-
-const stopSelenoid = () => exec(dockerStopScript)
-
-const checkDockerImage = () => exec(dockerImageCheckScript)
-
-const pullImage = async () => {
-  const { stdout } = await checkDockerImage()
-  const pulls = []
-  let resultPromise
-
-  output.print('Pulling in Selenoid containers. This may take a while when running the first time...')
-
-  console.time('Pulled containers')
-  if (!stdout.includes('selenoid/video-recorder')) {
-    output.debug('Pulling selenoid/video-recorder...')
-    resultPromise = exec('docker pull selenoid/video-recorder:latest-release').then(() =>
-      output.debug('Pulled in selenoid/video-recorder'),
-    )
-    pulls.push(resultPromise)
-  }
-  if (!stdout.includes('selenoid/chrome')) {
-    output.debug('Pulling selenoid/chrome...')
-    resultPromise = exec('docker pull selenoid/chrome:latest').then(() =>
-      output.debug('Pulled in selenoid/video-recorder'),
-    )
-    pulls.push(resultPromise)
-  }
-  if (!stdout.includes('selenoid/firefox')) {
-    output.debug('Pulling selenoid/firefox...')
-    resultPromise = exec('docker pull selenoid/firefox:latest').then(() => output.debug('Pulled in selenoid/chrome'))
-    pulls.push(resultPromise)
-  }
-
-  return Promise.all(pulls).then(() => {
-    console.timeEnd('Pulled containers')
-  })
-}
-
-function createAndStart(autoCreate) {
-  const selenoidCreated = autoCreate ? createSelenoidConfig().then(createSelenoid).then(pullImage) : Promise.resolve()
-  return selenoidCreated.then(startSelenoid).then(() => wait(SELENOID_START_TIMEOUT))
-}
-
-function deletePassedTests(passedTests) {
-  const deleteVideoPromiseList = passedTests
-    .map(clearString)
-    .map((test) => axios.delete(`${seleniumUrl}/video/${test}.mp4`))
-  const deleteLogPromiseList = passedTests
-    .map(clearString)
-    .map((test) => axios.delete(`${seleniumUrl}/logs/${test}.log`))
-
-  return Promise.all(deleteVideoPromiseList.concat(deleteLogPromiseList))
-    .then(() => output.debug('Deleted videos and logs for all passed tests'))
-    .catch((err) => output.error(`Error while deleting video and log files ${err.stack}`))
-}
-
-function setOptionsForWebdriver(config) {
-  const WebDriver = container.helpers('WebDriver')
-  WebDriver._setConfig(
-    deepMerge(WebDriver.options, {
-      capabilities: { 'selenoid:options': config },
-    }),
-  )
-}
-
-function setTestConfigForWebdriver(test) {
-  const WebDriver = container.helpers('WebDriver')
-  const fileName = clearString(test.title)
-  const { options } = WebDriver
-  recorder.add('setting selenoid capabilities', () => {
-    options.capabilities['selenoid:options'].name = test.title
-    options.capabilities['selenoid:options'].videoName = `${fileName}.mp4`
-    options.capabilities['selenoid:options'].logName = `${fileName}.log`
-    WebDriver._setConfig(options)
-  })
-}
-
-function replaceScriptConfig(config) {
-  for (const key of Object.keys(config)) {
-    dockerCreateScript = dockerCreateScript.replace(new RegExp(`\\$${key}\\$`, 'g'), config[key])
-  }
-  dockerStartScript = dockerStartScript.replace('$name$', config.name)
-  dockerStopScript = dockerStopScript.replace('$name$', config.name)
-  seleniumUrl = seleniumUrl.replace('$port$', config.port)
-}

package/lib/plugin/standardActingHelpers.js

@@ -1,3 +0,0 @@
-const standardActingHelpers = ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'TestCafe']
-
-module.exports = standardActingHelpers

package/lib/plugin/tryTo.js

@@ -1,115 +0,0 @@
-const recorder = require('../recorder')
-const { debug } = require('../output')
-
-const defaultConfig = {
-  registerGlobal: true,
-}
-
-/**
- *
- *
- * Adds global `tryTo` function in which all failed steps won't fail a test but will return true/false.
- *
- * Enable this plugin in `codecept.conf.js` (enabled by default for new setups):
- *
- * ```js
- * plugins: {
- *   tryTo: {
- *     enabled: true
- *   }
- * }
- * ```
- * Use it in your tests:
- *
- * ```js
- * const result = await tryTo(() => I.see('Welcome'));
- *
- * // if text "Welcome" is on page, result => true
- * // if text "Welcome" is not on page, result => false
- * ```
- *
- * Disables retryFailedStep plugin for steps inside a block;
- *
- * Use this plugin if:
- *
- * * you need to perform multiple assertions inside a test
- * * there is A/B testing on a website you test
- * * there is "Accept Cookie" banner which may surprisingly appear on a page.
- *
- * #### Usage
- *
- * #### Multiple Conditional Assertions
- *
- * ```js
- *
- * Add assert requires first:
- * ```js
- * const assert = require('assert');
- * ```
- * Then use the assertion:
- * const result1 = await tryTo(() => I.see('Hello, user'));
- * const result2 = await tryTo(() => I.seeElement('.welcome'));
- * assert.ok(result1 && result2, 'Assertions were not succesful');
- * ```
- *
- * ##### Optional click
- *
- * ```js
- * I.amOnPage('/');
- * tryTo(() => I.click('Agree', '.cookies'));
- * ```
- *
- * #### Configuration
- *
- * * `registerGlobal` - to register `tryTo` function globally, true by default
- *
- * If `registerGlobal` is false you can use tryTo from the plugin:
- *
- * ```js
- * const tryTo = codeceptjs.container.plugins('tryTo');
- * ```
- *
- */
-module.exports = function (config) {
-  config = Object.assign(defaultConfig, config)
-
-  if (config.registerGlobal) {
-    global.tryTo = tryTo
-  }
-  return tryTo
-}
-
-function tryTo(callback) {
-  let result = false
-  return recorder.add(
-    'tryTo',
-    () => {
-      recorder.session.start('tryTo')
-      process.env.TRY_TO = 'true'
-      callback()
-      recorder.add(() => {
-        result = true
-        recorder.session.restore('tryTo')
-        return result
-      })
-      recorder.session.catch((err) => {
-        result = false
-        const msg = err.inspect ? err.inspect() : err.toString()
-        debug(`Unsuccessful try > ${msg}`)
-        recorder.session.restore('tryTo')
-        return result
-      })
-      return recorder.add(
-        'result',
-        () => {
-          process.env.TRY_TO = undefined
-          return result
-        },
-        true,
-        false,
-      )
-    },
-    false,
-    false,
-  )
-}