eslint-plugin-cypress 3.1.1 → 3.3.0

package/CONTRIBUTING.md

@@ -2,15 +2,49 @@
 
 Thanks for taking the time to contribute! :smile:
 
+## Preparation
+
+* Fork and clone this repository
+* Branch from the default `master` branch using a descriptive new branch name
+* Install dependencies with `npm ci`
+
+## Rule references
+
+* Refer to the [ESLint documentation](https://eslint.org/docs/latest/) and the [Custom Rules](https://eslint.org/docs/latest/extend/custom-rules) page
+
+## New rule
+
 To add a new rule:
-  * Fork and clone this repository
-  * Generate a new rule (a [yeoman generator](https://github.com/eslint/generator-eslint) is available)
-  * Write test scenarios then implement logic
-  * Describe the rule in the generated `docs` file
-  * Run `npm test` to run [Jest](https://jestjs.io/) or
-  * Run `npm start` to run [Jest](https://jestjs.io/) in [watchAll](https://jestjs.io/docs/cli#--watchall) mode where it remains active and reruns when source changes are made
-  * Make sure all tests are passing
-  * Add the rule to the [README](README.md) file
-  * Create a PR
-
-Use the following commit message conventions: https://github.com/semantic-release/semantic-release#commit-message-format
+
+* Follow the instructions in the ESLint [generator-eslint](https://www.npmjs.com/package/generator-eslint) documentation to install [Yeoman](https://www.npmjs.com/package/yo) and the generator
+* Run the new rule generator `yo eslint:rule` and answer the questions
+  - select "ESLint Plugin"
+  - for "Type a short description of this rule" provide text which starts with one of "enforce", "require" or "disallow" (all lower case)
+* Yeoman creates three boilerplate files:
+  - `docs/rules/<rule-id>.md`
+  - `lib/rules/<rule-id>.js`
+  - `test/rules/<rule-id>.js`
+* Run `npm run lint-fix`
+* Address the linting errors by editing `lib/rules/<rule-id>.js`
+  - Add a `meta.messages` property (see [MessageIds](https://eslint.org/docs/latest/extend/custom-rules#messageids))
+  - Select the appropriate `meta.type` property using `problem`, `suggestion`, or `layout`
+* Complete the new rule by adding content to the three files previously created
+* Run `eslint-doc-generator` to generate automated documentation sections (see [Document generation](#document-generation) below)
+* Review documentation changes
+* Run `npm run lint`
+* Run `npm test` to run [Jest](https://jestjs.io/) (or run `npm start` to run [Jest](https://jestjs.io/) in [watchAll](https://jestjs.io/docs/cli#--watchall) mode where it remains active and reruns when source changes are made)
+* Make sure all tests are passing
+* Add the rule to [legacy.js](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/legacy.js) and to [flat.js](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/lib/flat.js)
+* Create a git commit with a commit message similar to: `feat: add rule <description>` (see [commit message conventions](https://github.com/semantic-release/semantic-release#commit-message-format))
+* Create a PR from your branch
+
+## Document generation
+
+This plugin uses the ESLint [eslint-doc-generator](https://www.npmjs.com/package/eslint-doc-generator) to generate consistent documentation.
+* Install with `npm install eslint-doc-generator -g`
+* Run `eslint-doc-generator` in the root directory of the plugin
+
+## Legacy tests
+
+* The directory [tests-legacy](https://github.com/cypress-io/eslint-plugin-cypress/tree/master/tests-legacy) contains tests which are compatible with the legacy [ESLint v8 RuleTester](https://eslint.org/docs/v8.x/integrate/nodejs-api#ruletester) utility. It is not expected to add new rules to this set of tests.
+* The directory [tests](https://github.com/cypress-io/eslint-plugin-cypress/tree/master/tests) is for tests compatible with the current [ESLint RuleTester](https://eslint.org/docs/latest/integrate/nodejs-api#ruletester).

package/FLAT-CONFIG.md

@@ -0,0 +1,146 @@
+# Cypress ESLint Plugin - Flat Config
+
+This document supplements the [README](README.md) document and describes how to use the Cypress ESLint Plugin (`eslint-plugin-cypress`) in an ESLint flat config environment.
+
+Usage with ESLint `8.57.0` and ESLint `9.x` is described.
+
+## Introduction
+
+[ESLint v9.0.0](https://eslint.org/blog/2024/04/eslint-v9.0.0-released/) was released on April 5, 2024, establishing flat config as the default for this version.
+
+Previously, ESLint had announced in their blog post [Flat config rollout plans](https://eslint.org/blog/2023/10/flat-config-rollout-plans/) in October 2023 that flat config was planned to be the default in ESLint `v9.0.0` and that the eslintrc configuration system is planned to be removed in the future ESLint `v10.0.0`.
+
+Cypress ESLint Plugin (`eslint-plugin-cypress`) in release [3.2.0](https://github.com/cypress-io/eslint-plugin-cypress/releases/tag/v3.2.0) offered the first support of ESLint `9.x` flat config files using the [Backwards compatibility utility](https://eslint.org/blog/2022/08/new-config-system-part-2/#backwards-compatibility-utility). Current releases have removed the dependency on this utility and the examples in this document have been updated correspondingly.
+
+The following information details installation and usage examples for `eslint-plugin-cypress` together with related plugins in an ESLint flat config environment.
+
+## Installation
+
+It is recommended to use a minimum ESLint `8.x` version [eslint@8.57.0](https://github.com/eslint/eslint/releases/tag/v8.57.0) or ESLint `9.x`.
+
+```shell
+npm install eslint eslint-plugin-cypress --save-dev
+```
+
+or
+
+```shell
+yarn add eslint eslint-plugin-cypress --dev
+```
+
+## Usage examples
+
+Add a flat configuration file `eslint.config.mjs` to the root directory of your Cypress project and include the following instructions to import the available flat configurations using:
+
+```shell
+import pluginCypress from 'eslint-plugin-cypress/flat'
+```
+
+There are two specific flat configurations available:
+
+| Configuration         | Content                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `configs.globals`     | defines globals `cy`, `Cypress`, `expect`, `assert` and `chai` used in Cypress test specs as well as `globals.browser` and `globals.mocha` from [globals](https://www.npmjs.com/package/globals). Additionally, `languageOptions` of `ecmaVersion: 2019` and `sourceType: 'module'` for backwards compatibility with earlier versions of this plugin are defined. There are no default rules enabled in this configuration. |
+| `configs.recommended` | enables [recommended Rules](README.md#rules). It includes also `configs.global` (see above)                                                                                                                                                                                                                                                                                                                                 |
+
+In the following sections, different examples of possible configuration file contents are given, together with some brief explanations. Adapt these examples according to your needs.
+
+### Cypress
+
+All rules from `eslint-plugin-cypress` are available through `eslint-plugin-cypress/flat`.
+- [cypress/unsafe-to-chain-command](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md) is active and set to `error`
+
+```js
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  {
+    plugins: {
+      cypress: pluginCypress
+    },
+    rules: {
+      'cypress/unsafe-to-chain-command': 'error'
+    }
+  }
+]
+```
+
+### Cypress recommended
+
+The `eslint-plugin-cypress` [recommended rules](README.md#rules) `configs.recommended` are activated, except for
+- [cypress/no-unnecessary-waiting](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md) set to `off`
+
+```js
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  pluginCypress.configs.recommended,
+  {
+    rules: {
+      'cypress/no-unnecessary-waiting': 'off'
+    }
+  }
+]
+```
+
+### Cypress globals
+
+The `configs.globals` are activated.
+
+```js
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  pluginCypress.configs.globals
+]
+```
+
+### Cypress and Mocha recommended
+
+[eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha) is added to the example [Cypress recommended](#cypress-recommended). This plugin offers a flat file recommended option `configs.flat.recommended`.
+
+The settings for individual `mocha` rules from the `configs.flat.recommended` option are changed.
+- [mocha/no-exclusive-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-exclusive-tests.md) and [mocha/no-skipped-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-skipped-tests.md) are set to `error` instead of `warn`
+- [mocha/no-mocha-arrows](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-mocha-arrows.md) is set to `off` instead of `error`
+
+```shell
+npm install eslint-plugin-mocha@^10.4.3 --save-dev
+```
+
+```js
+import pluginMocha from 'eslint-plugin-mocha'
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  pluginMocha.configs.flat.recommended,
+  pluginCypress.configs.recommended,
+  {
+    rules: {
+      'mocha/no-exclusive-tests': 'warn',
+      'mocha/no-skipped-tests': 'warn',
+      'mocha/no-mocha-arrows': 'off',
+      'cypress/no-unnecessary-waiting': 'off'
+    }
+  }
+]
+```
+
+### Cypress and Chai recommended
+
+[eslint-plugin-chai-friendly](https://www.npmjs.com/package/eslint-plugin-chai-friendly) (minimum version [eslint-plugin-chai-friendly@0.8.0](https://github.com/ihordiachenko/eslint-plugin-chai-friendly/releases/tag/v0.8.0) required for ESLint v9 support and flat config support) is combined with the Cypress plugin `eslint-plugin-cypress`.
+
+The recommended rules for both plugins are used: `pluginCypress.configs.recommended` and `pluginChaiFriendly.configs.recommended`:
+
+```shell
+npm install eslint-plugin-chai-friendly@^0.8.0 --save-dev
+```
+
+```js
+import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginChaiFriendly from 'eslint-plugin-chai-friendly'
+export default [
+  pluginCypress.configs.recommended,
+  pluginChaiFriendly.configs.recommended,
+  {
+    rules: {
+      'cypress/no-unnecessary-waiting': 'off',
+    },
+  }
+]
+```

package/README.md

@@ -6,7 +6,8 @@ Note: If you installed ESLint globally then you must also install `eslint-plugin
 
 ## Installation
 
-Prerequisites: [ESLint](https://www.npmjs.com/package/eslint) `v7` or `v8`. ESLint `v9` is **not** supported yet.
+Prerequisites: [ESLint](https://www.npmjs.com/package/eslint) `v7`, `v8` or `v9`.
+This plugin supports the use of [Flat config files](https://eslint.org/docs/latest/use/configure/configuration-files) with ESLint `8.57.0` and above.
 
 ```sh
 npm install eslint-plugin-cypress --save-dev
@@ -18,7 +19,9 @@ yarn add eslint-plugin-cypress --dev
 
 ## Usage
 
-Add an `.eslintrc.json` file to your `cypress` directory with the following:
+If you are using ESLint `v7` or `v8`, then add an `.eslintrc.json` file to the root directory of your Cypress project with the contents shown below. You can continue to use this format with ESLint `v9` if you set the `ESLINT_USE_FLAT_CONFIG` environment variable to `false` (see [ESLint v9 > Configuration Files (Deprecated)](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated).
+
+ESLint `v9` uses a [Flat config file](https://eslint.org/docs/latest/use/configure/configuration-files) format with filename `eslint.config.*js` by default. Please refer to [additional Flat config installation and configuration details](FLAT-CONFIG.md). (You may also use this with ESLint `8.57.0`.)
 
 ```json
 {

package/circle.yml

@@ -7,11 +7,13 @@ workflows:
       - lint
       - test-v7
       - test-v8
+      - test-v9
       - release:
           requires:
             - lint
             - test-v7
             - test-v8
+            - test-v9
           filters:
             branches:
               only:
@@ -52,7 +54,7 @@ jobs:
           command: npx eslint --version
       - run:
           name: Test ESLint 7
-          command: npm test
+          command: npm run test:legacy
 
   test-v8:
     docker:
@@ -70,6 +72,24 @@ jobs:
           command: npx eslint --version
       - run:
           name: Test ESLint 8
+          command: npm run test:legacy
+
+  test-v9:
+    docker:
+      - image: cimg/node:20.12.2
+    steps:
+      - checkout
+      - run:
+          name: Install dependencies
+          command: npm ci
+      - run:
+          name: Install ESLint 9
+          command: npm install eslint@9
+      - run:
+          name: Show ESLint version
+          command: npx eslint --version
+      - run:
+          name: Test ESLint 9
           command: npm test
 
   release:

package/eslint.config.mjs

@@ -0,0 +1,29 @@
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import eslintPlugin from 'eslint-plugin-eslint-plugin'
+import nodePlugin from 'eslint-plugin-n'
+import mochaPlugin from 'eslint-plugin-mocha'
+
+export default [
+  pluginJs.configs.recommended,
+  eslintPlugin.configs['flat/recommended'],
+  nodePlugin.configs['flat/recommended-script'],
+  mochaPlugin.configs.flat.recommended,
+  {
+    languageOptions: {
+      globals: globals.node
+    },
+    rules: {
+      'no-redeclare': 'off',
+      'eslint-plugin/require-meta-docs-url':
+        ['error', { 'pattern': 'https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/{{name}}.md' }],
+      'eslint-plugin/require-meta-docs-description': 'error',
+      'eslint-plugin/meta-property-ordering': 'error',
+      'eslint-plugin/test-case-property-ordering': 'error',
+      'n/no-extraneous-require':
+        ['error', { 'allowModules': ['jest-config'] }],
+      'mocha/no-mocha-arrows': 'off',
+      'mocha/no-setup-in-describe': 'off'
+    }
+  },
+]

package/jest.config-legacy.js

@@ -0,0 +1,6 @@
+const { defaults } = require('jest-config')
+
+module.exports = {
+  testMatch: ['**/tests-legacy/**/*.[jt]s?(x)'],
+  testPathIgnorePatterns: [...defaults.testPathIgnorePatterns, '.history'],
+}

package/lib/flat.js

@@ -0,0 +1,66 @@
+const globals = require('globals')
+const { name, version } = require('../package.json')
+
+const plugin = {
+  meta: { name, version },
+  configs: {},
+  rules: {
+    'no-assigning-return-values': require('./rules/no-assigning-return-values'),
+    'unsafe-to-chain-command': require('./rules/unsafe-to-chain-command'),
+    'no-unnecessary-waiting': require('./rules/no-unnecessary-waiting'),
+    'no-async-before': require('./rules/no-async-before'),
+    'no-async-tests': require('./rules/no-async-tests'),
+    'assertion-before-screenshot': require('./rules/assertion-before-screenshot'),
+    'require-data-selectors': require('./rules/require-data-selectors'),
+    'no-force': require('./rules/no-force'),
+    'no-pause': require('./rules/no-pause'),
+  },
+}
+
+const commonGlobals =
+  Object.assign({
+    cy: false,
+    Cypress: false,
+    expect: false,
+    assert: false,
+    chai: false,
+  }, globals.browser, globals.mocha)
+
+const commonLanguageOptions = {
+  ecmaVersion: 2019,
+  sourceType: 'module'
+}
+
+Object.assign(plugin.configs, {
+  globals: {
+    plugins: {
+      cypress: plugin
+    },
+    languageOptions: {
+      globals:
+        commonGlobals,
+      ...commonLanguageOptions
+    }
+  }
+})
+
+Object.assign(plugin.configs, {
+  recommended: {
+    plugins: {
+      cypress: plugin
+    },
+    rules: {
+      'cypress/no-assigning-return-values': 'error',
+      'cypress/no-unnecessary-waiting': 'error',
+      'cypress/no-async-tests': 'error',
+      'cypress/unsafe-to-chain-command': 'error',
+    },
+    languageOptions: {
+      globals:
+        commonGlobals,
+      ...commonLanguageOptions
+    }
+  }
+})
+
+module.exports = plugin

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "eslint-plugin-cypress",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "An ESLint plugin for projects using Cypress",
-  "main": "index.js",
+  "main": "legacy.js",
+  "exports": {
+    ".": "./legacy.js",
+    "./flat": "./lib/flat.js"
+  },
   "author": "Cypress-io",
   "license": "MIT",
   "keywords": [
@@ -19,16 +23,18 @@
   },
   "homepage": "https://github.com/cypress-io/eslint-plugin-cypress#readme",
   "peerDependencies": {
-    "eslint": ">=7 <9"
+    "eslint": ">=7"
   },
   "dependencies": {
     "globals": "^13.20.0"
   },
   "devDependencies": {
-    "eslint": "^8.57.0",
-    "eslint-plugin-eslint-plugin": "^6.0.0",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.3.0",
+    "eslint": "^9.3.0",
+    "eslint-plugin-eslint-plugin": "^6.1.0",
     "eslint-plugin-mocha": "^10.4.3",
-    "eslint-plugin-n": "^17.2.1",
+    "eslint-plugin-n": "^17.7.0",
     "husky": "^9.0.11",
     "jest": "^29.7.0",
     "semantic-release": "23.0.8"
@@ -39,6 +45,7 @@
     "semantic-release": "semantic-release",
     "start": "npm run test-watch",
     "test": "jest",
+    "test:legacy": "jest --config jest.config-legacy.js",
     "test-watch": "jest --watchAll",
     "prepare": "husky"
   }

package/tests/config.js

@@ -2,10 +2,10 @@
 'use strict'
 
 const globals = require('globals')
-const config = require('../index.js')
+const config = require('../lib/flat.js')
 
-describe('environments globals', () => {
-  const env = config.environments.globals
+describe('globals languageOptions', () => {
+  const languageOptions = config.configs.globals.languageOptions
 
   it('should not mutate globals', () => {
     expect(globals.browser).not.toHaveProperty('cy')
@@ -13,12 +13,12 @@ describe('environments globals', () => {
   })
 
   it('should include other globals', () => {
-    expect(env.globals).toEqual(expect.objectContaining(globals.browser))
-    expect(env.globals).toEqual(expect.objectContaining(globals.mocha))
+    expect(languageOptions.globals).toEqual(expect.objectContaining(globals.browser))
+    expect(languageOptions.globals).toEqual(expect.objectContaining(globals.mocha))
   })
 
   it('should include cypress globals', () => {
-    expect(env.globals).toEqual(expect.objectContaining({
+    expect(languageOptions.globals).toEqual(expect.objectContaining({
       cy: false,
       Cypress: false,
     }))

package/tests/lib/rules/assertion-before-screenshot.js

@@ -6,30 +6,29 @@ const RuleTester = require('eslint').RuleTester
 const ruleTester = new RuleTester()
 
 const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 6 }
 
 ruleTester.run('assertion-before-screenshot', rule, {
   valid: [
-    { code: 'cy.get(".some-element"); cy.screenshot();', parserOptions },
-    { code: 'cy.get(".some-element").should("exist").screenshot();', parserOptions },
-    { code: 'cy.get(".some-element").should("exist").screenshot().click()', parserOptions, errors },
-    { code: 'cy.get(".some-element").should("exist"); if(true) cy.screenshot();', parserOptions },
-    { code: 'if(true) { cy.get(".some-element").should("exist"); cy.screenshot(); }', parserOptions },
-    { code: 'cy.get(".some-element").should("exist"); if(true) { cy.screenshot(); }', parserOptions },
-    { code: 'const a = () => { cy.get(".some-element").should("exist"); cy.screenshot(); }', parserOptions, errors },
-    { code: 'cy.get(".some-element").should("exist").and("be.visible"); cy.screenshot();', parserOptions },
-    { code: 'cy.get(".some-element").contains("Text"); cy.screenshot();', parserOptions },
+    { code: 'cy.get(".some-element"); cy.screenshot();' },
+    { code: 'cy.get(".some-element").should("exist").screenshot();' },
+    { code: 'cy.get(".some-element").should("exist").screenshot().click()' },
+    { code: 'cy.get(".some-element").should("exist"); if(true) cy.screenshot();' },
+    { code: 'if(true) { cy.get(".some-element").should("exist"); cy.screenshot(); }' },
+    { code: 'cy.get(".some-element").should("exist"); if(true) { cy.screenshot(); }' },
+    { code: 'const a = () => { cy.get(".some-element").should("exist"); cy.screenshot(); }' },
+    { code: 'cy.get(".some-element").should("exist").and("be.visible"); cy.screenshot();' },
+    { code: 'cy.get(".some-element").contains("Text"); cy.screenshot();' },
   ],
 
   invalid: [
-    { code: 'cy.screenshot()', parserOptions, errors },
-    { code: 'cy.visit("somepage"); cy.screenshot();', parserOptions, errors },
-    { code: 'cy.custom(); cy.screenshot()', parserOptions, errors },
-    { code: 'cy.get(".some-element").click(); cy.screenshot()', parserOptions, errors },
-    { code: 'cy.get(".some-element").click().screenshot()', parserOptions, errors },
-    { code: 'if(true) { cy.get(".some-element").click(); cy.screenshot(); }', parserOptions, errors },
-    { code: 'cy.get(".some-element").click(); if(true) { cy.screenshot(); }', parserOptions, errors },
-    { code: 'cy.get(".some-element"); function a() { cy.screenshot(); }', parserOptions, errors },
-    { code: 'cy.get(".some-element"); const a = () => { cy.screenshot(); }', parserOptions, errors },
+    { code: 'cy.screenshot()', errors },
+    { code: 'cy.visit("somepage"); cy.screenshot();', errors },
+    { code: 'cy.custom(); cy.screenshot()', errors },
+    { code: 'cy.get(".some-element").click(); cy.screenshot()', errors },
+    { code: 'cy.get(".some-element").click().screenshot()', errors },
+    { code: 'if(true) { cy.get(".some-element").click(); cy.screenshot(); }', errors },
+    { code: 'cy.get(".some-element").click(); if(true) { cy.screenshot(); }', errors },
+    { code: 'cy.get(".some-element"); function a() { cy.screenshot(); }', errors },
+    { code: 'cy.get(".some-element"); const a = () => { cy.screenshot(); }', errors },
   ],
 })

package/tests/lib/rules/no-assigning-return-values.js

@@ -6,33 +6,32 @@ const RuleTester = require('eslint').RuleTester
 const ruleTester = new RuleTester()
 
 const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 6 }
 
 ruleTester.run('no-assigning-return-values', rule, {
   valid: [
-    { code: 'var foo = true;', parserOptions },
-    { code: 'let foo = true;', parserOptions },
-    { code: 'const foo = true;', parserOptions },
-    { code: 'const foo = bar();', parserOptions },
-    { code: 'const foo = bar().baz();', parserOptions },
-    { code: 'const spy = cy.spy();', parserOptions },
-    { code: 'const spy = cy.spy().as();', parserOptions },
-    { code: 'const stub = cy.stub();', parserOptions },
-    { code: 'const result = cy.now();', parserOptions },
-    { code: 'const state = cy.state();', parserOptions },
-    { code: 'cy.get("foo");', parserOptions },
-    { code: 'cy.contains("foo").click();', parserOptions },
+    { code: 'var foo = true;' },
+    { code: 'let foo = true;' },
+    { code: 'const foo = true;' },
+    { code: 'const foo = bar();' },
+    { code: 'const foo = bar().baz();' },
+    { code: 'const spy = cy.spy();' },
+    { code: 'const spy = cy.spy().as();' },
+    { code: 'const stub = cy.stub();' },
+    { code: 'const result = cy.now();' },
+    { code: 'const state = cy.state();' },
+    { code: 'cy.get("foo");' },
+    { code: 'cy.contains("foo").click();' },
   ],
 
   invalid: [
-    { code: 'let a = cy.get("foo")', parserOptions, errors },
-    { code: 'const a = cy.get("foo")', parserOptions, errors },
-    { code: 'var a = cy.get("foo")', parserOptions, errors },
+    { code: 'let a = cy.get("foo")', errors },
+    { code: 'const a = cy.get("foo")', errors },
+    { code: 'var a = cy.get("foo")', errors },
 
-    { code: 'let a = cy.contains("foo")', parserOptions, errors },
-    { code: 'let a = cy.window()', parserOptions, errors },
-    { code: 'let a = cy.wait("@something")', parserOptions, errors },
+    { code: 'let a = cy.contains("foo")', errors },
+    { code: 'let a = cy.window()', errors },
+    { code: 'let a = cy.wait("@something")', errors },
 
-    { code: 'let a = cy.contains("foo").click()', parserOptions, errors },
+    { code: 'let a = cy.contains("foo").click()', errors },
   ],
 })

package/tests/lib/rules/no-async-before.js

@@ -6,20 +6,18 @@ const RuleTester = require('eslint').RuleTester
 const ruleTester = new RuleTester()
 
 const errors = [{ messageId: 'unexpected' }]
-// async functions are an ES2017 feature
-const parserOptions = { ecmaVersion: 8 }
 
 ruleTester.run('no-async-before', rule, {
   valid: [
-    { code: 'before(\'a before case\', () => { cy.get(\'.someClass\'); })', parserOptions },
-    { code: 'before(\'a before case\', async () => { await somethingAsync(); })', parserOptions },
-    { code: 'async function nonTestFn () { return await somethingAsync(); }', parserOptions },
-    { code: 'const nonTestArrowFn = async () => { await somethingAsync(); }', parserOptions },
+    { code: 'before(\'a before case\', () => { cy.get(\'.someClass\'); })' },
+    { code: 'before(\'a before case\', async () => { await somethingAsync(); })' },
+    { code: 'async function nonTestFn () { return await somethingAsync(); }' },
+    { code: 'const nonTestArrowFn = async () => { await somethingAsync(); }' },
   ],
   invalid: [
-    { code: 'before(\'a test case\', async () => { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'beforeEach(\'a test case\', async () => { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'before(\'a test case\', async function () { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'beforeEach(\'a test case\', async function () { cy.get(\'.someClass\'); })', parserOptions, errors },
+    { code: 'before(\'a test case\', async () => { cy.get(\'.someClass\'); })', errors },
+    { code: 'beforeEach(\'a test case\', async () => { cy.get(\'.someClass\'); })', errors },
+    { code: 'before(\'a test case\', async function () { cy.get(\'.someClass\'); })', errors },
+    { code: 'beforeEach(\'a test case\', async function () { cy.get(\'.someClass\'); })', errors },
   ],
 })

package/tests/lib/rules/no-async-tests.js

@@ -6,20 +6,18 @@ const RuleTester = require('eslint').RuleTester
 const ruleTester = new RuleTester()
 
 const errors = [{ messageId: 'unexpected' }]
-// async functions are an ES2017 feature
-const parserOptions = { ecmaVersion: 8 }
 
 ruleTester.run('no-async-tests', rule, {
   valid: [
-    { code: 'it(\'a test case\', () => { cy.get(\'.someClass\'); })', parserOptions },
-    { code: 'it(\'a test case\', async () => { await somethingAsync(); })', parserOptions },
-    { code: 'async function nonTestFn () { return await somethingAsync(); }', parserOptions },
-    { code: 'const nonTestArrowFn = async () => { await somethingAsync(); }', parserOptions },
+    { code: 'it(\'a test case\', () => { cy.get(\'.someClass\'); })' },
+    { code: 'it(\'a test case\', async () => { await somethingAsync(); })' },
+    { code: 'async function nonTestFn () { return await somethingAsync(); }' },
+    { code: 'const nonTestArrowFn = async () => { await somethingAsync(); }' },
   ],
   invalid: [
-    { code: 'it(\'a test case\', async () => { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'test(\'a test case\', async () => { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'it(\'a test case\', async function () { cy.get(\'.someClass\'); })', parserOptions, errors },
-    { code: 'test(\'a test case\', async function () { cy.get(\'.someClass\'); })', parserOptions, errors },
+    { code: 'it(\'a test case\', async () => { cy.get(\'.someClass\'); })', errors },
+    { code: 'test(\'a test case\', async () => { cy.get(\'.someClass\'); })', errors },
+    { code: 'it(\'a test case\', async function () { cy.get(\'.someClass\'); })', errors },
+    { code: 'test(\'a test case\', async function () { cy.get(\'.someClass\'); })', errors },
   ],
 })