orb.yml

version: 2.1
description: |
  Run your Cypress.io end-to-end browser tests without spending time configuring CircleCI.
  This orb can also record results on the Cypress Dashboard and load balance tests in parallel mode.
  If recording on the dashboard, set `CYPRESS_RECORD_KEY` as CI environment variable.
  Repo: https://github.com/cypress-io/circleci-orb

#
# See https://www.cypress.io/
#
# User workflows can use "Jobs" defined in this Orb
# Jobs can use "Commands" also defined in this Orb
# Commands run on "Executors" defined below to guarantee consistent environment
# with all dependencies installed correctly.

#
# environments (containers) for running jobs and commands
#
executors:
  default:
    description: Single Docker container with Cypress dependencies
    parameters:
      node:
        type: string
        default: '10'
        description: Version of Node 6/8/10 to use
    docker:
      - image: cypress/base:<< parameters.node >>

  # executors based on available Cypress docker images
  # see https://github.com/cypress-io/cypress-docker-images
  # see https://hub.docker.com/r/cypress/base/tags
  base-6:
    description: Single Docker container with Node 6 and Cypress dependencies
    docker:
      - image: cypress/base:6

  base-8:
    description: Single Docker container with Node 8 and Cypress dependencies
    docker:
      - image: cypress/base:8

  base-10:
    description: Single Docker container with Node 10 and Cypress dependencies
    docker:
      - image: cypress/base:10

  base-12-6-0:
    description: Single Docker container with Node 12.6.0 and Cypress dependencies
    docker:
      - image: cypress/base:12.6.0

  browsers-chrome69:
    description: Docker container with Node 10, Cypress dependencies and Chrome 69
    docker:
      - image: cypress/browsers:chrome69

  browsers-chrome73:
    description: Docker container with Node 11.13.0, Cypress dependencies and Chrome 73
    docker:
      - image: cypress/browsers:node11.13.0-chrome73

  browsers-chrome74:
    description: Docker container with Node 10.1.2, Cypress dependencies and Chrome 74
    docker:
      - image: cypress/browsers:node10.2.1-chrome74

  browsers-chrome75:
    description: Docker container with Node 12.6.0, Cypress dependencies and Chrome 75
    docker:
      - image: cypress/browsers:node12.6.0-chrome75

  browsers-chrome76:
    description: Docker container with Node 10.16.0, Cypress dependencies and Chrome 69
    docker:
      - image: cypress/browsers:node10.16.0-chrome76
#
# reusable commands
#
commands:
  #
  # individual "building blocks" commands
  #
  setup:
    parameters:
      executor:
        description: Executor to use
        type: executor
        default: base-10
      build:
        description: Optional build command(s)
        type: steps
        default: []
      yarn:
        description: Use yarn instead of npm
        type: boolean
        default: false
      cache-key:
        description: Npm cache key
        type: string
        default: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "package.json" }}'
      working_directory:
        description: Directory containing package.json
        type: string
        default: ''
    steps:
      - restore_cache:
          keys:
            - << parameters.cache-key >>
      # it would be nice to vary this command based on presence of "package-lock.json"
      # and also allow using yarn or pnpm
      - when:
          condition: << parameters.yarn >>
          steps:
            - run:
                name: 'Yarn install'
                command: 'yarn install --frozen-lockfile'
                working_directory: << parameters.working_directory >>
      - unless:
          condition: << parameters.yarn >>
          steps:
            - run:
                name: 'Check if package-lock.json exists'
                command: |
                  if [ ! -e ./package-lock.json ]; then
                    echo "The Cypress orb uses 'npm ci' to install 'node_modules', which requires a 'package-lock.json'."
                    echo "A 'package-lock.json' file was not found. Please run 'npm install' in your project,"
                    echo "and commit 'package-lock.json' to your repo."
                    exit 1
                  fi
                working_directory: << parameters.working_directory >>
            - run:
                name: 'Npm CI'
                command: 'npm ci'
                working_directory: << parameters.working_directory >>
      - run:
          name: 'Verify Cypress'
          command: npx cypress verify
          working_directory: << parameters.working_directory >>
      # save new cache folder if needed
      - when:
          condition: << parameters.yarn >>
          steps:
            - save_cache:
                key: << parameters.cache-key >>
                paths:
                  - ~/.cache
      - unless:
          condition: << parameters.yarn >>
          steps:
            - save_cache:
                key: << parameters.cache-key >>
                paths:
                  - ~/.npm
                  - ~/.cache
      - steps: << parameters.build >>

  write_workspace:
    steps:
      - persist_to_workspace:
          root: ~/
          paths:
            - project
            - .cache/Cypress

  #
  # public user commands
  #

  # Install command
  install:
    description: |
      Install NPM dependencies using "npm ci" or "yarn install --frozen-lockfile" then optionally runs your build command
    parameters:
      build:
        type: steps
        default: []
        description: Custom build commands to run after install
      yarn:
        description: Use yarn instead of npm
        type: boolean
        default: false
      cache-key:
        description: Npm cache key
        type: string
        default: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "package.json" }}'
      no-workspace:
        description: |
          Do not write workspace (for example if there are no jobs to follow)
        type: boolean
        default: false
      working_directory:
        description: Directory containing package.json
        type: string
        default: ''
    steps:
      - setup:
          build: << parameters.build >>
          yarn: << parameters.yarn >>
          cache-key: << parameters.cache-key >>
          working_directory: << parameters.working_directory >>
      - unless:
          condition: << parameters.no-workspace >>
          steps:
            - write_workspace

#
# jobs defined by the orb
#
jobs:
  # a single e2e test run that
  #   - checks out code
  #   - installs NPM dependencies
  #     * (optional) run custom build command
  #   - executes Cypress end-to-end tests
  #     * (optional) starts server in the background
  #     * (optional) records tests results on Cypress Dashboard:
  #       - (optional) splits tests across N machines
  #       - (optional) names tests with a group name
  #       - (optional) use custom run tests command
  run:
    description:
      A single complete job to run Cypress end-to-end tests in your project.
      If recording on the Dashboard, set `CYPRESS_RECORD_KEY` environment variable

    parameters:
      executor:
        type: executor
        default: base-10
        description: |
          Cypress executor to use, see [executors.md](executors.md).
          You can define your own executor, see examples.

      record:
        type: boolean
        default: false
        description: |
          Record results on Cypress Dashboard, see https://on.cypress.io/dashboard-service.
          This option is necessary to enable other related flags, like `parallel` and `group`.

      # "parallel" parameter should be used with "parallelism" parameter
      parallel:
        type: boolean
        default: false
        description: |
          Use test balancing using Cypress Dashboard,
          see https://on.cypress.io/parallelization. Requires `record: true` and
          only makes sense with CircleCI `parallelism` setting to spin several CI machines.
          Related options "record" and "group".

      parallelism:
        type: integer
        default: 1
        description: |
          Number of Circle machines to use for load balancing, min 1
          (requires "parallel" parameter set to true, and requires `record: true`)

      group:
        type: string
        default: ''
        description: |
          Test group name when recording on the dashboard. Requires `record: true`

      build:
        type: string
        default: ''
        description: |
          Custom build command to run after install to build your application.
          Related parameter "start"

      start:
        type: string
        default: ''
        description: |
          Optional server start command to run in the background before running Cypress tests.
          Related parameters "build" and "wait-on".

      wait-on:
        type: string
        default: ''
        description: |
          Optional url check using `wait-on` utility. Useful to delay tests until server boots and responds.
          Example:
            wait-on: "http://localhost:4200" # wait for local port 4200 to respond to HEAD request
            wait-on: "http-get://127.0.0.1:3000" # wait for port 3000 to respond to GET request

      browser:
        type: string
        default: ''
        description: |
          Browser to use to run end-to-end tests. Typically "electron" (default) or "chrome".
          See https://on.cypress.io/launching-browsers, requires using executor with the browser installed,
          electron browser is already included with Cypress.

      spec:
        type: string
        default: ''
        description: |
          Spec pattern to use to run only some test files, passed as `--spec ...` CLI argument.

      command:
        type: string
        default: ''
        description: |
          Custom test command to run Cypress tests, which overrides all individual options.

      store_artifacts:
        type: boolean
        default: false
        description: |
          Store Cypress-generated screenshots and videos as CircleCI test artifacts.
          See https://circleci.com/docs/2.0/artifacts/

      yarn:
        description: Use yarn to install NPM modules instead of npm.
        type: boolean
        default: false

      cache-key:
        description: |
          Custom CircleCI cache key for storing NPM modules and Cypress binary.
        type: string
        default: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "package.json" }}'

      no-workspace:
        description: |
          Do not write workspace (for example if there are no jobs to follow), which
          saves time on each build.
        type: boolean
        default: false

      working_directory:
        description: |
          Directory containing package.json. Use this parameter if you're using a monorepo and your
          cypress tests aren't at the root of the repository (eg. `frontend`).
        type: string
        default: ''

      timeout:
        description: Optional timeout for running tests
        type: string
        default: 10m

    executor: <<parameters.executor>>
    parallelism: <<parameters.parallelism>>

    steps:
      - when:
          condition: << parameters.parallel >>
          # user wants to run in parallel mode
          # thus we assume the dependencies were installed as separate job
          # hmm, can we detect if this job requires cypress/install automatically?
          steps:
            - run: echo "Assuming dependencies were installed using cypress/install job"
            - attach_workspace:
                at: ~/

      - unless:
          condition: << parameters.parallel >>
          steps:
            - checkout
            - when:
                condition: << parameters.build >>
                steps:
                  - install:
                      yarn: << parameters.yarn >>
                      cache-key: << parameters.cache-key >>
                      no-workspace: << parameters.no-workspace >>
                      build:
                        - run: << parameters.build >>
                      working_directory: << parameters.working_directory >>
            - unless:
                condition: <<parameters.build>>
                steps:
                  - install:
                      cache-key: << parameters.cache-key >>
                      yarn: << parameters.yarn >>
                      no-workspace: << parameters.no-workspace >>
                      working_directory: << parameters.working_directory >>

      - when:
          condition: <<parameters.start>>
          steps:
            - run:
                name: Start
                command: <<parameters.start>>
                background: true
                working_directory: << parameters.working_directory >>

      - when:
          condition: <<parameters.wait-on>>
          steps:
            - run:
                name: Wait-on <<parameters.wait-on>>
                command: npx wait-on <<parameters.wait-on>>

      - when:
          condition: <<parameters.command>>
          steps:
            - run:
                command: <<parameters.command>>
                working_directory: << parameters.working_directory >>

      - unless:
          condition: <<parameters.command>>
          steps:
            - run:
                name: Run Cypress tests
                no_output_timeout: <<parameters.timeout>>
                # GOOD EXAMPLE conditional text based on boolean parameter
                # --record is needed to pass many other arguments, like "--group" and "--parallel"
                command: |
                  npx cypress run \
                    <<# parameters.spec>> --spec '<<parameters.spec>>' <</ parameters.spec>> \
                    <<# parameters.browser>> --browser <<parameters.browser>> <</ parameters.browser>> \
                    <<# parameters.record >> --record \
                      <<# parameters.group>> --group '<<parameters.group>>' <</ parameters.group>> \
                      <<# parameters.parallel>> --parallel <</ parameters.parallel>> \
                    <</ parameters.record>>
                working_directory: << parameters.working_directory >>

      - when:
          condition: << parameters.store_artifacts >>
          # store videos and screenshots (if any) as Circle artifacts
          # https://circleci.com/docs/2.0/artifacts/
          steps:
            - store_artifacts:
                path: cypress/videos
            - store_artifacts:
                path: cypress/screenshots

  # Install Job that can be performed before running jobs
  # often used to have a single installation step, and then
  # multiple run jobs can share the same pre-installed workspace.
  install:
    parameters:
      executor:
        type: executor
        default: base-10
        description: Cypress or custom executor name to use to run the install.
      build:
        type: string
        default: ''
        description: |
          Custom build command to run after install to build the web application or web server.
      cache-key:
        description: Npm cache key
        type: string
        default: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "package.json" }}'
      yarn:
        description: Use yarn to install NPM modules instead of npm.
        type: boolean
        default: false
      working_directory:
        description: |
          Directory containing package.json. Use this parameter if you're using a monorepo and your
          cypress tests aren't at the root of the repository (eg. `frontend`). Additionally,
          monorepo users will want to provide a `cache-key` parameter to key the cache with an
          appropriate checksum. (i.e. `cache-key: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "frontend/package.json" }}'`)
        type: string
        default: ''
    description: |
      Checks out code, installs dependencies, attaches code to the workspace for the future jobs
      to use (usually `cypress/run` follows the install step).
    executor: <<parameters.executor>>
    steps:
      - checkout
      - when:
          condition: << parameters.build >>
          steps:
            - install:
                yarn: << parameters.yarn >>
                build:
                  - run:
                      name: 'Build'
                      command: << parameters.build >>
                working_directory: << parameters.working_directory >>
                cache-key: << parameters.cache-key >>
      - unless:
          condition: << parameters.build >>
          steps:
            - install:
                yarn: << parameters.yarn >>
                working_directory: << parameters.working_directory >>
                cache-key: << parameters.cache-key >>

#
# User examples showing how to use the above Cypress Orb
#
examples:
  simple:
    description: |
      Runs all Cypress tests without recording results on the Dashboard.
      Installs dependencies with "npm ci", caches NPM modules and Cypress binary.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run

  yarn:
    description: |
      Installs NPM dependencies using "yarn install --frozen-lockfile" command,
      then runs Cypress tests. Caches NPM modules and Cypress binary.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                yarn: true

  custom-directory:
    description: |
      Runs all commands in a custom directory, this is useful when using a monorepo where
      the `package.json` file isn't at the root of the repository
      (eg. in the `frontend/subfolder`).
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                yarn: true
                working_directory: frontend

  custom-cache-key:
    description: |
      Apply custom key for npm install (or yarn install) cache.
      Useful to tweak caching settings to your liking. Related options "yarn".
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                yarn: true
                cache-key: yarn-packages-{{ arch }}-{{ checksum "yarn.lock" }}

  custom-cache-and-directory:
    description: |
      Monorepo users may want to provide a `cache-key` parameter to key the cache
      with an appropriate checksum.
      (i.e. `cache-key: 'cache-{{ arch }}-{{ .Branch }}-{{ checksum "frontend/package.json" }}'`)
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/install:
                cache-key: cache-{{ arch }}-{{ .Branch }}-{{ checksum "frontend/package.json" }}
            - cypress/run:
                yarn: true
                cache-key: cache-{{ arch }}-{{ .Branch }}-{{ checksum "frontend/package.json" }}
                working_directory: frontend

  using-node6:
    description: |
      Runs all Cypress tests on Node 6 image by specifying `executor` name.
      There are several executors included with this orb, and you can use
      your own executor, see "custom-executor" example.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                executor: cypress/base-6

  recording:
    description: |
      Runs all Cypress tests and records them on the
      [Cypress Dashboard](https://on.cypress.io/dashboard-service).
      Requires `CYPRESS_RECORD_KEY` environment variable to be set.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                record: true

  artifacts:
    description: |
      Stores test screenshots and videos as CircleCI artifacts using "store_artifacts" job option.
      Note, this setting assumes the default Cypress folders for screenshots and videos.
      If you store screenshots and videos in custom folders, see "any-artifacts" example how
      to store arbitrary folders.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                store_artifacts: true

  any-artifacts:
    description: |
      Stores additional folders like "mochawesome-report" or code coverage folder
      as a CircleCI artifact. Related option "artifacts".
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                post-steps:
                  - store_artifacts:
                      path: mochawesome-report

  chrome:
    description: |
      Runs tests using Chrome browser in a custom executor - a Docker image
      that includes Chrome browser. See [`--browser`](https://on.cypress.io/launching-browsers)
      Cypress run option documentation.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                executor: cypress/browsers-chrome69
                browser: chrome

  start-server:
    description: |
      Often we need to start a local webserver before running end-to-end tests.
      This option runs the given command to starts the server in the background
      and then runs all Cypress tests. Related option "wait-on".
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                start: 'npm start'

  wait-for-server-to-respond:
    description: |
      Starts server, waits for it to respond and then runs all Cypress tests.
      Uses `npx wait-on ...` command under the hood, see [wait-on](https://github.com/jeffbski/wait-on#readme).
      Note, if you are using Webpack server, it might not respond to the default HTTP OPTIONS request.
      In that case use `wait-on` to send `HTTP GET` request by using url `wait-on: 'http-get://localhost:....'`.
      You can also pass `wait-on` config, see [issue #90](https://github.com/cypress-io/circleci-orb/issues/90).
      Related option "start"
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                start: 'npm start'
                wait-on: 'http://localhost:4200'

  parallel-on-2-machines:
    description: |
      Runs all Cypress tests by load balancing them on two machines. Note that
      first a single job installs NPM dependencies, then 2 jobs run the tests
      in parallel using Cypress Dashboard [parallelization](https://on.cypress.io/parallelization).
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/install
            - cypress/run:
                requires:
                  - cypress/install
                record: true
                parallel: true
                parallelism: 2
                group: '2 machines'

  install-private-npm-modules:
    description: |
      In this example, we write the NPM auth token before running "npm install" command.
      This allows us to install private NPM modules for example.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/install:
                pre-steps:
                  - run: echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
            - cypress/run:
                requires:
                  - cypress/install

  build-app:
    description: |
      Install dependencies and run a custom build command on one machine that builds the
      web application. Then runs Cypress tests on 3 machines and balances them using
      [Dashboard parallelization](https://on.cypress.io/parallelization).
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/install:
                build: 'npm run build' # custom build command
            - cypress/run:
                requires:
                  - cypress/install
                record: true
                parallel: true
                parallelism: 3
                group: '3x'

  groups:
    description: |
      Runs all tests on 4 machines using Electron browser (default).
      Also runs some tests using "spec" parameter on Chrome browser.
      Records both groups on Cypress dashboard. Notice "name" under each "cypress/run" job
      which will be shown in the Circle workflow UI to tell jobs apart.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/install
            - cypress/run:
                name: '4 machines'
                requires:
                  - cypress/install
                record: true
                parallel: true
                parallelism: 4
                group: '4 machines'
            - cypress/run:
                name: 'Chrome'
                requires:
                  - cypress/install
                executor: cypress/browsers-chrome69
                record: true
                parallel: true
                parallelism: 2
                group: 'smoke tests'
                browser: 'chrome'
                spec: 'cypress/integration/smoke/*'

  release:
    description: |
      If you want to run an entire job after running Cypress tests, you can
      reuse the workspace from the `cypress/run` job. For example,
      to run a semantic release script you could follow this example.
      Note - for simpler steps you can use "post-steps" parameter, see "store-test-reports" example.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      jobs:
        release:
          executor: cypress/base-10
          steps:
            # the workspace saved by cypress/install
            - attach_workspace:
                at: ~/
            - run: npm run semantic-release
      workflows:
        build:
          jobs:
            - cypress/install
            - cypress/run:
                requires:
                  - cypress/install
            - release:
                requires:
                  - cypress/run

  linux-and-mac:
    description: |
      Runs tests on Linux and on Mac via two jobs. Note how the user defines and uses own executor "mac"
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1

      executors:
        mac:
          macos:
            xcode: '10.1.0'

      workflows:
        build:
          jobs:
            - cypress/run:
                name: Linux test
            - cypress/run:
                name: Mac test
                executor: mac

  custom-executor:
    description: |
      Use any executor to run the job defined by the orb.
      Assumes the executor has all OS dependencies necessary to run Cypress.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1

      executors:
        with-chrome:
          docker:
            - image: cypress/browsers:chrome69

      workflows:
        build:
          jobs:
            - cypress/run:
                executor: with-chrome

  store-test-reports:
    description: |
      Stores test results using post-steps parameter, see https://on.cypress.io/reporters,
      assumes that reports are saved in folder "cypress/results". Also see "artifacts" parameter.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1

      workflows:
        build:
          jobs:
            - cypress/run:
                post-steps:
                  - store_test_results:
                      path: cypress/results

  env-vars:
    description: |
      Set additional environment variables when running Cypress tests by
      adding them to the executor.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1

      executors:
        base10-foo-bar:
          docker:
            - image: cypress/base:10
          environment:
            FOO: 'foo'
            BAR: 'bar'

      workflows:
        build:
          jobs:
            - cypress/run:
                executor: base10-foo-bar

  custom-command:
    description: Use your own arbitrary command to launch Cypress tests.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                command: npx cypress run --record

  no-workspace:
    description: |
      Faster "cypress/run" job that does not attach workspace,
      because there are no jobs that follow, so no need to save files.
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                no-workspace: true

  private-npm-module:
    description: |
      This example shows how to install private NPM modules using NPM_TOKEN environment
      variable using "pre-steps" parameter. Then it starts the server, waits for it to respond
      and runs Cypress tests. Then it publishes a new version of the current module
      using semantic-release script (using the same NPM_TOKEN variable to publish).
    usage:
      version: 2.1
      orbs:
        cypress: cypress-io/cypress@1
      workflows:
        build:
          jobs:
            - cypress/run:
                pre-steps:
                  - run: 'echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc'
                no-workspace: true
                start: npm start
                wait-on: 'http://localhost:3003'
                post-steps:
                  - run: npm run semantic-release

##
## Development (internal)
##
## process this workflow using above jobs and commands like inline orb
## Useful for local developing, especially by showing the effective config
## using: npm run effective:config
# workflows:
#   build:
#     jobs:
#       - run:
#           no-workspace: true