eslint-plugin-cypress 4.2.1 → 5.0.0

package/.node-version

@@ -1 +1 @@
-22.11.0
+22.16.0

package/.nvmrc

@@ -1 +1 @@
-22.11.0
+22.16.0

package/CONTRIBUTING.md

@@ -34,7 +34,7 @@ To add a new rule:
 * 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)
+* Add the rule 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
 
@@ -44,7 +44,28 @@ This plugin uses the ESLint [eslint-doc-generator](https://www.npmjs.com/package
 * Install with `npm install eslint-doc-generator -g`
 * Run `eslint-doc-generator` in the root directory of the plugin
 
-## Legacy tests
+## Merging pull requests
 
-* 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).
+This information is for Cypress.io Members or Collaborators who merge pull requests:
+
+1. When merging a pull request, use the [Squash and merge](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/about-merge-methods-on-github#squashing-your-merge-commits) option to squash all commits into one.
+1. Make sure the commit subject and body follow [semantic commit convention](https://semantic-release.gitbook.io/semantic-release/#commit-message-format), for instance:
+
+   ```text
+   feat: added new parameter
+   fix: fixed a bug
+   ```
+
+   If you need to bump the major version, mark it as breaking change in the body of the commit's message like:
+
+   ```text
+   fix: upgrade dependency X
+
+   BREAKING CHANGE: requires minimum Node.js 20 to run
+   ```
+
+1. New versions of this module will be released automatically by the CI pipeline when any PR with a triggering commit message is merged to the `master` branch: see the `release` job of [circle.yml](circle.yml).
+This will create a new [GitHub release](https://github.com/cypress-io/eslint-plugin-cypress/releases) and publish it to [eslint-plugin-cypress](https://www.npmjs.com/package/eslint-plugin-cypress) on the [npm registry](https://docs.npmjs.com/about-the-public-npm-registry).
+1. The module's CI is configured to use the [default Angular release rules](https://github.com/semantic-release/commit-analyzer/blob/master/lib/default-release-rules.js).
+This means that only `feat:`, `fix:` and `perf:` trigger a new release.
+Other Angular commit types listed in the [Angular commit message guidelines](https://github.com/angular/angular/blob/main/contributing-docs/commit-message-guidelines.md) can be used for documentation purposes, however they are ignored by the currently configured release process.

package/ESLINTRC-CONFIG.md

@@ -1,147 +1,7 @@
 # Cypress ESLint Plugin - Legacy Config
 
-This document supplements the [README](./README.md) document and describes how to use the Cypress ESLint Plugin (`eslint-plugin-cypress`) in a [deprecated ESLint legacy config environment](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated). The use of flat configurations with this plugin is described in the [README](./README.md) document.
+This document previously described how to use the Cypress ESLint Plugin (`eslint-plugin-cypress`) with an [ESLint legacy config environment](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated).
 
-Usage with ESLint `9.x` is described.
+This form of configuration was deprecated with the release of ESLint `v9` and its use with `eslint-plugin-cypress` is no longer supported.
 
-## Deprecations
-
-The use of `eslintrc` configurations with `eslint-plugin-cypress` is deprecated and support will be removed in a future version of this plugin. This is tied in to the ESLint announcement in the blog post [Flat config rollout plans](https://eslint.org/blog/2023/10/flat-config-rollout-plans/) from October 2023 which describes that the `eslintrc` configuration system is planned to be removed in the future ESLint `v10.0.0`. Users are encouraged to migrate to using a [flat configuration](https://eslint.org/docs/latest/use/configure/configuration-files).
-
-## Installation
-
-Use a minimum ESLint `9.x`.
-
-```shell
-npm install eslint eslint-plugin-cypress --save-dev
-```
-
-or
-
-```shell
-yarn add eslint eslint-plugin-cypress --dev
-```
-
-## Usage
-
-To use a deprecated configuration with ESLint `v9`, such as `.eslintrc.json`, you must 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)). The following examples use `json` format for the content of the configuration file:
-
-```json
-{
-  "plugins": [
-    "cypress"
-  ]
-}
-```
-
-You can add rules - see [Rules](./README.md#rules) for a list of the available rules:
-
-```json
-{
-  "rules": {
-    "cypress/no-assigning-return-values": "error",
-    "cypress/no-unnecessary-waiting": "error",
-    "cypress/assertion-before-screenshot": "warn",
-    "cypress/no-force": "warn",
-    "cypress/no-async-tests": "error",
-    "cypress/no-async-before": "error",
-    "cypress/no-pause": "error",
-    "cypress/no-debug": "error"
-  }
-}
-```
-
-You can allow certain globals provided by Cypress:
-
-```json
-{
-  "env": {
-    "cypress/globals": true
-  }
-}
-```
-
-## Recommended configuration
-
-Use the recommended configuration and you can forego configuring _plugins_, _rules_, and _env_ individually. See [Rules](./README.md#rules) for which rules are included in the recommended configuration.
-
-```json
-{
-  "extends": [
-    "plugin:cypress/recommended"
-  ]
-}
-```
-
-## Rules
-
-See the [Rules](./README.md#rules) list in the main [README](./README.md) document.
-
-## Mocha and Chai
-
-Cypress is built on top of [Mocha](https://on.cypress.io/guides/references/bundled-libraries#Mocha) and [Chai](https://on.cypress.io/guides/references/bundled-libraries#Chai). See the following sections for information on using ESLint plugins [eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha) and [eslint-plugin-chai-friendly](https://www.npmjs.com/package/eslint-plugin-chai-friendly) together with `eslint-plugin-cypress`.
-
-## Mocha `.only` and `.skip`
-
-During test spec development, [Mocha exclusive tests](https://mochajs.org/#exclusive-tests) `.only` or [Mocha inclusive tests](https://mochajs.org/#inclusive-tests) `.skip` may be used to control which tests are executed, as described in the Cypress documentation [Excluding and Including Tests](https://on.cypress.io/guides/core-concepts/writing-and-organizing-tests#Excluding-and-Including-Tests). To apply corresponding rules, you can install and use [eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha). The rule [mocha/no-exclusive-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-exclusive-tests.md) detects the use of `.only` and the [mocha/no-skipped-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-skipped-tests.md) rule detects the use of `.skip`:
-
-```sh
-npm install --save-dev eslint-plugin-mocha
-```
-
-In your `.eslintrc.json`:
-
-```json
-{
-  "plugins": [
-    "cypress",
-    "mocha"
-  ],
-  "rules": {
-    "mocha/no-exclusive-tests": "warn",
-    "mocha/no-skipped-tests": "warn"
-  }
-}
-```
-
-Or you can simply use the `cypress/recommended` and `mocha/recommended` configurations together, for example:
-
-```json
-{
-  "extends": [
-    "plugin:cypress/recommended",
-    "plugin:mocha/recommended"
-  ]
-}
-```
-
-## Chai and `no-unused-expressions`
-
-Using an assertion such as `expect(value).to.be.true` can fail the ESLint rule `no-unused-expressions` even though it's not an error in this case. To fix this, you can install and use [eslint-plugin-chai-friendly](https://www.npmjs.com/package/eslint-plugin-chai-friendly).
-
-```sh
-npm install --save-dev eslint-plugin-chai-friendly
-```
-
-In your `.eslintrc.json`:
-
-```json
-{
-  "plugins": [
-    "cypress",
-    "chai-friendly"
-  ],
-  "rules": {
-    "no-unused-expressions": 0,
-    "chai-friendly/no-unused-expressions": 2
-  }
-}
-```
-
-Or you can simply add its `recommended` config:
-
-```json
-{
-  "extends": ["plugin:chai-friendly/recommended"]
-}
-```
+Users who were previously using a deprecated configuration environment should migrate to a [flat configuration](https://eslint.org/docs/latest/use/configure/configuration-files).

package/FLAT-CONFIG.md

@@ -1,5 +1,3 @@
 # Cypress ESLint Plugin - Flat Config
 
- Please refer to the [README](./README.md) document where the previous contents of this document, describing how to use `eslint-plugin-cypress` with an ESLint `v9` (default) [flat configuration](https://eslint.org/docs/latest/use/configure/configuration-files), can now be found.
-
-For instructions on using a deprecated [eslintrc-type](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated) config file from previous ESLint `v8` versions and below, please refer to the [ESLINTRC-CONFIG](./ESLINTRC-CONFIG.md) document.
+ Please refer to the [README](./README.md) document which describes how to use `eslint-plugin-cypress` with an ESLint `v9` (default) [flat configuration](https://eslint.org/docs/latest/use/configure/configuration-files).

package/README.md

@@ -18,21 +18,27 @@ yarn add eslint eslint-plugin-cypress --dev
 
 ## Usage
 
-ESLint `v9` uses a [Flat config file](https://eslint.org/docs/latest/use/configure/configuration-files) format with filename `eslint.config.*js` by default. For instructions on using a deprecated [eslintrc-type](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated) config file from previous ESLint versions, please refer to the [ESLINTRC-CONFIG](./ESLINTRC-CONFIG.md) document.
+ESLint `v9` uses a [Flat config file](https://eslint.org/docs/latest/use/configure/configuration-files) format with filename `eslint.config.*js` by default. This plugin no longer supports the use of a deprecated [eslintrc-type](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated) config file from previous ESLint versions.
 
-To set up a flat configuration, add a file `eslint.config.mjs` to the root directory of your Cypress project and include the following instructions to import the available flat configurations using:
+To set up a configuration, add a file `eslint.config.mjs` to the root directory of your Cypress project and include the following instructions to import the available configurations using:
 
 ```shell
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
+```
+
+For backwards compatibility with previous plugin versions `3.3.0` - `4.3.0`, the following equivalent deprecated form is also supported. This is planned to be removed in a future major version:
+
+```shell
+import pluginCypress from 'eslint-plugin-cypress/flat' # deprecated
 ```
 
 ## Configurations
 
-There are two specific flat configurations available:
+There are two specific 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). This version no longer specifies `languageOptions` for `ecmaVersion` and `sourceType` - see ESLint [JavaScript languageOptions](https://eslint.org/docs/latest/use/configure/language-options#specifying-javascript-options). There are no default rules enabled in this configuration. |
+| `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). There are no default rules enabled in this configuration. |
 | `configs.recommended` | enables [recommended Rules](#rules). It includes also `configs.global` (see above).                                                                                                                                                                                                                                                                                                                                                                                               |
 
 ## Rules
@@ -50,6 +56,7 @@ These rules enforce some of the [best practices recommended for using Cypress](h
 | [no-assigning-return-values](docs/rules/no-assigning-return-values.md)   | disallow assigning return values of `cy` calls             | ✅  |
 | [no-async-before](docs/rules/no-async-before.md)                         | disallow using `async`/`await` in Cypress `before` methods |    |
 | [no-async-tests](docs/rules/no-async-tests.md)                           | disallow using `async`/`await` in Cypress test cases       | ✅  |
+| [no-chained-get](docs/rules/no-chained-get.md)                           | disallow chain of `cy.get()` calls                         |    |
 | [no-debug](docs/rules/no-debug.md)                                       | disallow using `cy.debug()` calls                          |    |
 | [no-force](docs/rules/no-force.md)                                       | disallow using `force: true` with action commands          |    |
 | [no-pause](docs/rules/no-pause.md)                                       | disallow using `cy.pause()` calls                          |    |
@@ -66,11 +73,11 @@ In the following sections, different examples of possible configuration file con
 
 ### Cypress
 
-All rules from `eslint-plugin-cypress` are available through `eslint-plugin-cypress/flat` and can be individually activated.
+All rules are available by importing from `eslint-plugin-cypress` and can be individually activated.
 - [cypress/unsafe-to-chain-command](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md) is activated and set to `error`
 
 ```js
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   {
     plugins: {
@@ -89,7 +96,7 @@ The `eslint-plugin-cypress` [recommended rules](#rules) `configs.recommended` ar
 - [cypress/no-unnecessary-waiting](https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md) which is set to `off`
 
 ```js
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.recommended,
   {
@@ -105,7 +112,7 @@ export default [
 The `configs.globals` are activated.
 
 ```js
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.globals
 ]
@@ -156,34 +163,34 @@ it('waits for a second', () => {
 
 ## Mocha and Chai
 
-Cypress is built on top of [Mocha](https://on.cypress.io/guides/references/bundled-libraries#Mocha) and [Chai](https://on.cypress.io/guides/references/bundled-libraries#Chai). See the following sections for information on using ESLint plugins [eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha) and [eslint-plugin-chai-friendly](https://www.npmjs.com/package/eslint-plugin-chai-friendly) together with `eslint-plugin-cypress`.
+Cypress is built on top of [Mocha](https://on.cypress.io/app/references/bundled-libraries#Mocha) and [Chai](https://on.cypress.io/app/references/bundled-libraries#Chai). See the following sections for information on using ESLint plugins [eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha) and [eslint-plugin-chai-friendly](https://www.npmjs.com/package/eslint-plugin-chai-friendly) together with `eslint-plugin-cypress`.
 
 ## Mocha `.only` and `.skip`
 
-During test spec development, [Mocha exclusive tests](https://mochajs.org/#exclusive-tests) `.only` or [Mocha inclusive tests](https://mochajs.org/#inclusive-tests) `.skip` may be used to control which tests are executed, as described in the Cypress documentation [Excluding and Including Tests](https://on.cypress.io/guides/core-concepts/writing-and-organizing-tests#Excluding-and-Including-Tests). To apply corresponding rules, you can install and use [eslint-plugin-mocha](https://www.npmjs.com/package/eslint-plugin-mocha). The rule [mocha/no-exclusive-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-exclusive-tests.md) detects the use of `.only` and the [mocha/no-skipped-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-skipped-tests.md) rule detects the use of `.skip`.
+During test spec development, [Mocha exclusive tests](https://mochajs.org/#exclusive-tests) `.only` or [Mocha inclusive tests](https://mochajs.org/#inclusive-tests) `.skip` may be used to control which tests are executed, as described in the Cypress documentation [Excluding and Including Tests](https://on.cypress.io/app/core-concepts/writing-and-organizing-tests#Excluding-and-Including-Tests). To apply corresponding rules, you can install and use [eslint-plugin-mocha@^11](https://www.npmjs.com/package/eslint-plugin-mocha) plugin version or above. The rule [mocha/no-exclusive-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-exclusive-tests.md) detects the use of `.only` and the [mocha/no-pending-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-pending-tests.md) rule detects the use of `.skip`.
 
 ### 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`.
+[eslint-plugin-mocha@^11](https://www.npmjs.com/package/eslint-plugin-mocha) is added to the example [Cypress recommended](#cypress-recommended). This version of the plugin supports only flat file configurations with the option `configs.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`
+The settings for individual `mocha` rules from the `configs.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-pending-tests](https://github.com/lo1tuma/eslint-plugin-mocha/blob/main/docs/rules/no-pending-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.5.0 --save-dev
+npm install eslint-plugin-mocha@^11 --save-dev
 ```
 
 ```js
 import pluginMocha from 'eslint-plugin-mocha'
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
-  pluginMocha.configs.flat.recommended,
+  pluginMocha.configs.recommended,
   pluginCypress.configs.recommended,
   {
     rules: {
       'mocha/no-exclusive-tests': 'error',
-      'mocha/no-skipped-tests': 'error',
+      'mocha/no-pending-tests': 'error',
       'mocha/no-mocha-arrows': 'off',
       'cypress/no-unnecessary-waiting': 'off'
     }
@@ -204,7 +211,7 @@ npm install eslint-plugin-chai-friendly@^1.0.1 --save-dev
 ```
 
 ```js
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 import pluginChaiFriendly from 'eslint-plugin-chai-friendly'
 export default [
   pluginCypress.configs.recommended,

package/circle.yml

@@ -3,14 +3,13 @@ version: 2.1
 executors:
   docker-executor:
     docker:
-      - image: cimg/node:22.14.0
+      - image: cimg/node:22.16.0
     resource_class: medium
 
 workflows:
   main:
     jobs:
       - lint
-      - test-v8
       - test-v9
 
       - build-test-project
@@ -21,6 +20,7 @@ workflows:
               config-file: [
                   # configurations correspond to examples in README
                   'default',
+                  'default-deprecated', # using deprecated /flat
                   'recommended',
                   'globals',
                 ]
@@ -29,7 +29,6 @@ workflows:
       - release:
           requires:
             - lint
-            - test-v8
             - test-v9
             - test-test-project
           filters:
@@ -52,23 +51,6 @@ jobs:
           name: Lint code
           command: npm run lint
 
-  test-v8:
-    executor: docker-executor
-    steps:
-      - checkout
-      - run:
-          name: Install dependencies
-          command: npm ci
-      - run:
-          name: Install ESLint 8
-          command: npm install eslint@8
-      - run:
-          name: Show ESLint version
-          command: npx eslint --version
-      - run:
-          name: Test ESLint 8
-          command: npm run test:legacy
-
   test-v9:
     executor: docker-executor
     steps:

package/docs/rules/no-chained-get.md

@@ -0,0 +1,19 @@
+# Disallow chain of `cy.get()` calls (`cypress/no-chained-get`)
+
+<!-- end auto-generated rule header -->
+This rule disallows the usage of chained `.get()` calls as `cy.get()` always starts its search from the cy.root element.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```js
+cy.get('parent').get('child')
+```
+
+Examples of **correct** code for this rule:
+
+```js
+cy.get('parent')
+  .find('child')
+```

package/eslint.config.mjs

@@ -6,7 +6,7 @@ import mochaPlugin from 'eslint-plugin-mocha'
 export default [
   pluginJs.configs.recommended,
   eslintPlugin.configs['flat/recommended'],
-  mochaPlugin.configs.flat.recommended,
+  mochaPlugin.configs.recommended,
   {ignores: ['test-project/']},
   {
     languageOptions: {

package/lib/flat.js

@@ -5,17 +5,18 @@ const plugin = {
   meta: { name, version },
   configs: {},
   rules: {
+    'assertion-before-screenshot': require('./rules/assertion-before-screenshot'),
     '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-chained-get': require('./rules/no-chained-get'),
+    'no-debug': require('./rules/no-debug'),
     'no-force': require('./rules/no-force'),
     'no-pause': require('./rules/no-pause'),
-    'no-debug': require('./rules/no-debug'),
+    'no-unnecessary-waiting': require('./rules/no-unnecessary-waiting'),
     'no-xpath': require('./rules/no-xpath'),
+    'require-data-selectors': require('./rules/require-data-selectors'),
+    'unsafe-to-chain-command': require('./rules/unsafe-to-chain-command'),
   },
 }
 

package/lib/rules/no-chained-get.js

@@ -0,0 +1,87 @@
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow chain of `cy.get()` calls',
+      recommended: false,
+      url: 'https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-chained-get.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      unexpected: 'Avoid chaining multiple cy.get() calls',
+    },
+  },
+
+  create(context) {
+    const isRootCypress = (node) => {
+      if (
+        node.type !== 'CallExpression' ||
+        node.callee.type !== 'MemberExpression'
+      ) {
+        return false;
+      }
+
+      if (
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'cy'
+      ) {
+        return true;
+      }
+
+      return isRootCypress(node.callee.object);
+    };
+
+    const hasChainedGet = (node) => {
+      // Check if this node is a get() call
+      const isGetCall =
+        node.callee &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.property &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'get';
+
+      if (!isGetCall) {
+        return false;
+      }
+
+      const obj = node.callee.object;
+
+      if (obj.type === 'CallExpression') {
+        const objCallee = obj.callee;
+
+        if (
+          objCallee &&
+          objCallee.type === 'MemberExpression' &&
+          objCallee.property &&
+          objCallee.property.type === 'Identifier' &&
+          objCallee.property.name === 'get'
+        ) {
+          return true;
+        }
+
+        return hasChainedGet(obj);
+      }
+
+      return false;
+    };
+
+    return {
+      CallExpression(node) {
+        if (isRootCypress(node) && hasChainedGet(node)) {
+          context.report({
+            node,
+            messageId: 'unexpected',
+          });
+        }
+      },
+    };
+  },
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "eslint-plugin-cypress",
-  "version": "4.2.1",
+  "version": "5.0.0",
   "description": "An ESLint plugin for projects using Cypress",
-  "main": "legacy.js",
+  "main": "./lib/flat.js",
   "exports": {
-    ".": "./legacy.js",
+    ".": "./lib/flat.js",
     "./flat": "./lib/flat.js"
   },
   "author": "Cypress-io",
@@ -26,23 +26,22 @@
     "eslint": ">=9"
   },
   "dependencies": {
-    "globals": "^15.15.0"
+    "globals": "^16.2.0"
   },
   "devDependencies": {
-    "eslint": "^9.24.0",
+    "eslint": "^9.27.0",
     "eslint-plugin-eslint-plugin": "^6.4.0",
-    "eslint-plugin-mocha": "^10.5.0",
+    "eslint-plugin-mocha": "^11.1.0",
     "husky": "^9.1.7",
     "jest": "^29.7.0",
-    "semantic-release": "24.2.3"
+    "semantic-release": "24.2.5"
   },
   "scripts": {
-    "lint": "eslint \"*.js\" \"**/**/*.js\"",
-    "lint-fix": "npm run lint -- --fix",
+    "lint": "eslint",
+    "lint-fix": "eslint --fix",
     "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/test-project/eslint-configs/eslint.default-deprecated.mjs

@@ -0,0 +1,11 @@
+// eslint-plugin-cypress/flat is deprecated and is identical to
+// eslint-plugin-cypress
+import pluginCypress from 'eslint-plugin-cypress/flat'
+export default [
+  pluginCypress.configs.recommended,
+  {
+    rules: {
+      'cypress/no-unnecessary-waiting': 'off'
+    }
+  }
+]

package/test-project/eslint-configs/eslint.default.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.recommended,
   {

package/test-project/eslint-configs/eslint.globals.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.globals
 ]

package/test-project/eslint-configs/eslint.recommended.mjs

@@ -1,4 +1,4 @@
-import pluginCypress from 'eslint-plugin-cypress/flat'
+import pluginCypress from 'eslint-plugin-cypress'
 export default [
   pluginCypress.configs.recommended,
   {

package/tests/lib/rules/no-chained-get.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview disallow chain of `cy.get()` calls
+ * @author benoit
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../../lib/rules/no-chained-get"),
+  RuleTester = require("eslint").RuleTester;
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester();
+ruleTester.run("no-chained-get", rule, {
+  valid: [
+    { code: "cy.get('div')" },
+    { code: "cy.get('.div').find().get()" },
+    { code: "cy.get('input').should('be.disabled')" },
+  ],
+  invalid: [
+    {
+      code: "cy.get('div').get('div')",
+      errors: [{ messageId: "unexpected" }],
+    },
+  ],
+});

package/jest.config-legacy.js

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

package/legacy.js

@@ -1,35 +0,0 @@
-const globals = require('globals')
-
-module.exports = {
-  rules: {
-    'no-assigning-return-values': require('./lib/rules/no-assigning-return-values'),
-    'unsafe-to-chain-command': require('./lib/rules/unsafe-to-chain-command'),
-    'no-unnecessary-waiting': require('./lib/rules/no-unnecessary-waiting'),
-    'no-async-before': require('./lib/rules/no-async-before'),
-    'no-async-tests': require('./lib/rules/no-async-tests'),
-    'assertion-before-screenshot': require('./lib/rules/assertion-before-screenshot'),
-    'require-data-selectors': require('./lib/rules/require-data-selectors'),
-    'no-force': require('./lib/rules/no-force'),
-    'no-pause': require('./lib/rules/no-pause'),
-    'no-debug': require('./lib/rules/no-debug'),
-    'no-xpath': require('./lib/rules/no-xpath'),
-  },
-  configs: {
-    recommended: require('./lib/config/recommended'),
-  },
-  environments: {
-    globals: {
-      globals: Object.assign({
-        cy: false,
-        Cypress: false,
-        expect: false,
-        assert: false,
-        chai: false,
-      }, globals.browser, globals.mocha),
-      parserOptions: {
-        ecmaVersion: 2019,
-        sourceType: 'module',
-      },
-    },
-  },
-}

package/tests-legacy/config.js

@@ -1,26 +0,0 @@
-/* global describe, it, expect */
-'use strict'
-
-const globals = require('globals')
-const config = require('../legacy.js')
-
-describe('environments globals', () => {
-  const env = config.environments.globals
-
-  it('should not mutate globals', () => {
-    expect(globals.browser).not.toHaveProperty('cy')
-    expect(globals.mocha).not.toHaveProperty('cy')
-  })
-
-  it('should include other globals', () => {
-    expect(env.globals).toEqual(expect.objectContaining(globals.browser))
-    expect(env.globals).toEqual(expect.objectContaining(globals.mocha))
-  })
-
-  it('should include cypress globals', () => {
-    expect(env.globals).toEqual(expect.objectContaining({
-      cy: false,
-      Cypress: false,
-    }))
-  })
-})

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

@@ -1,35 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/assertion-before-screenshot')
-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 },
-  ],
-
-  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 },
-  ],
-})

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

@@ -1,38 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/no-assigning-return-values')
-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 },
-  ],
-
-  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.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").click()', parserOptions, errors },
-  ],
-})

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

@@ -1,25 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/no-async-before')
-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 },
-  ],
-  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 },
-  ],
-})

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

@@ -1,25 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/no-async-tests')
-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 },
-  ],
-  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 },
-  ],
-})

package/tests-legacy/lib/rules/no-force.js

@@ -1,49 +0,0 @@
-'use strict'
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const rule = require('../../../lib/rules/no-force')
-
-const RuleTester = require('eslint').RuleTester
-
-const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 2018 }
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-let ruleTester = new RuleTester()
-
-ruleTester.run('no-force', rule, {
-
-  valid: [
-    { code: `cy.get('button').click()`, parserOptions },
-    { code: `cy.get('button').click({multiple: true})`, parserOptions },
-    { code: `cy.get('button').dblclick()`, parserOptions },
-    { code: `cy.get('input').type('somth')`, parserOptions },
-    { code: `cy.get('input').type('somth', {anyoption: true})`, parserOptions },
-    { code: `cy.get('input').trigger('click', {anyoption: true})`, parserOptions },
-    { code: `cy.get('input').rightclick({anyoption: true})`, parserOptions },
-    { code: `cy.get('input').check()`, parserOptions },
-    { code: `cy.get('input').select()`, parserOptions },
-    { code: `cy.get('input').focus()`, parserOptions },
-    { code: `cy.document().trigger("keydown", { ...event })`, parserOptions },
-  ],
-
-  invalid: [
-    { code: `cy.get('button').click({force: true})`, parserOptions, errors },
-    { code: `cy.get('button').dblclick({force: true})`, parserOptions, errors },
-    { code: `cy.get('input').type('somth', {force: true})`, parserOptions, errors },
-    { code: `cy.get('div').find('.foo').type('somth', {force: true})`, parserOptions, errors },
-    { code: `cy.get('div').find('.foo').find('.bar').click({force: true})`, parserOptions, errors },
-    { code: `cy.get('div').find('.foo').find('.bar').trigger('change', {force: true})`, parserOptions, errors },
-    { code: `cy.get('input').trigger('click', {force: true})`, parserOptions, errors },
-    { code: `cy.get('input').rightclick({force: true})`, parserOptions, errors },
-    { code: `cy.get('input').check({force: true})`, parserOptions, errors },
-    { code: `cy.get('input').select({force: true})`, parserOptions, errors },
-    { code: `cy.get('input').focus({force: true})`, parserOptions, errors },
-  ],
-})

package/tests-legacy/lib/rules/no-pause.js

@@ -1,37 +0,0 @@
-'use strict'
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const rule = require('../../../lib/rules/no-pause')
-
-const RuleTester = require('eslint').RuleTester
-
-const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 2018 }
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const ruleTester = new RuleTester()
-
-ruleTester.run('no-pause', rule, {
-
-  valid: [
-    { code: `pause()`, parserOptions },
-    { code: `cy.get('button').dblclick()`, parserOptions },
-  ],
-  
-  invalid: [
-    { code: `cy.pause()`, parserOptions, errors },
-    { code: `cy.pause({ log: false })`, parserOptions, errors },
-    { code: `cy.get('button').pause()`, parserOptions, errors },
-    { 
-      code: `cy.get('a').should('have.attr', 'href').and('match', /dashboard/).pause()`, 
-      parserOptions, 
-      errors 
-    }
-  ],
-})

package/tests-legacy/lib/rules/no-unnecessary-waiting.js

@@ -1,71 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/no-unnecessary-waiting')
-const RuleTester = require('eslint').RuleTester
-
-const ruleTester = new RuleTester()
-
-const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 6, sourceType: 'module' }
-
-ruleTester.run('no-unnecessary-waiting', rule, {
-  valid: [
-    { code: 'foo.wait(10)', parserOptions },
-
-    { code: 'cy.wait("@someRequest")', parserOptions },
-    { code: 'cy.wait("@someRequest", { log: false })', parserOptions },
-    { code: 'cy.wait("@someRequest").then((xhr) => xhr)', parserOptions },
-    { code: 'cy.wait(["@someRequest", "@anotherRequest"])', parserOptions },
-
-    { code: 'cy.clock(5000)', parserOptions },
-    { code: 'cy.scrollTo(0, 10)', parserOptions },
-    { code: 'cy.tick(500)', parserOptions },
-
-    { code: 'const someRequest="@someRequest"; cy.wait(someRequest)', parserOptions, errors },
-    { code: 'function customWait (alias = "@someRequest") { cy.wait(alias) }', parserOptions, errors },
-    { code: 'const customWait = (alias = "@someRequest") => { cy.wait(alias) }', parserOptions, errors },
-    { code: 'function customWait (ms) { cy.wait(ms) }', parserOptions, errors },
-    { code: 'const customWait = (ms) => { cy.wait(ms) }', parserOptions, errors },
-
-    { code: 'import BAR_BAZ from "bar-baz"; cy.wait(BAR_BAZ)', parserOptions },
-    { code: 'import { FOO_BAR } from "foo-bar"; cy.wait(FOO_BAR)', parserOptions },
-    { code: 'import * as wildcard from "wildcard"; cy.wait(wildcard.value)', parserOptions },
-    { code: 'import { NAME as OTHER_NAME } from "rename"; cy.wait(OTHER_NAME)', parserOptions },
-
-    // disable the eslint rule
-    {
-      code: `
-        cy.wait(100); // eslint-disable-line no-unnecessary-waiting
-      `,
-      parserOptions,
-    },
-    {
-      code: `
-        /* eslint-disable-next-line no-unnecessary-waiting */
-        cy.wait(100)
-      `,
-      parserOptions,
-    },
-    {
-      code: `
-        /* eslint-disable no-unnecessary-waiting */
-        cy.wait(100)
-        /* eslint-enable no-unnecessary-waiting */
-      `,
-      parserOptions,
-    },
-  ],
-
-  invalid: [
-    { code: 'cy.wait(0)', parserOptions, errors },
-    { code: 'cy.wait(100)', parserOptions, errors },
-    { code: 'cy.wait(5000)', parserOptions, errors },
-    { code: 'const someNumber=500; cy.wait(someNumber)', parserOptions, errors },
-    { code: 'function customWait (ms = 1) { cy.wait(ms) }', parserOptions, errors },
-    { code: 'const customWait = (ms = 1) => { cy.wait(ms) }', parserOptions, errors },
-
-    { code: 'cy.get(".some-element").wait(10)', parserOptions, errors },
-    { code: 'cy.get(".some-element").contains("foo").wait(10)', parserOptions, errors },
-    { code: 'const customWait = (ms = 1) => { cy.get(".some-element").wait(ms) }', parserOptions, errors },
-  ],
-})

package/tests-legacy/lib/rules/require-data-selectors.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/require-data-selectors')
-const RuleTester = require('eslint').RuleTester
-
-const ruleTester = new RuleTester()
-
-const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 6 }
-
-ruleTester.run('require-data-selectors', rule, {
-  valid: [
-    { code: 'cy.get(\'[data-cy=submit]\').click()', parserOptions },
-    { code: 'cy.get(\'[data-QA=submit]\')', parserOptions },
-    { code: 'cy.clock(5000)', parserOptions },
-    { code: 'cy.scrollTo(0, 10)', parserOptions },
-    { code: 'cy.tick(500)', parserOptions },
-    { code: 'cy.get(\`[data-cy=${1}]\`)', parserOptions }, // eslint-disable-line no-useless-escape
-    { code: 'cy.get("@my-alias")', parserOptions, errors },
-    { code: 'cy.get(`@my-alias`)', parserOptions, errors },
-  ],
-
-  invalid: [
-    { code: 'cy.get(\'[daedta-cy=submit]\').click()', parserOptions, errors },
-    { code: 'cy.get(\'[d-cy=submit]\')', parserOptions, errors },
-    { code: 'cy.get(".btn-large").click()', parserOptions, errors },
-    { code: 'cy.get(".btn-.large").click()', parserOptions, errors },
-    { code: 'cy.get(".a")', parserOptions, errors },
-    { code: 'cy.get(\`[daedta-cy=${1}]\`)', parserOptions, errors }, // eslint-disable-line no-useless-escape
-  ],
-})

package/tests-legacy/lib/rules/unsafe-to-chain-command.js

@@ -1,56 +0,0 @@
-'use strict'
-
-const rule = require('../../../lib/rules/unsafe-to-chain-command')
-const RuleTester = require('eslint').RuleTester
-
-const ruleTester = new RuleTester()
-
-const errors = [{ messageId: 'unexpected' }]
-const parserOptions = { ecmaVersion: 6 }
-
-ruleTester.run('action-ends-chain', rule, {
-  valid: [
-    {
-      code: 'cy.get("new-todo").type("todo A{enter}"); cy.get("new-todo").type("todo B{enter}"); cy.get("new-todo").should("have.class", "active");',
-      parserOptions,
-    },
-    {
-      code: 'cy.focused().should("be.visible");',
-      parserOptions,
-    },
-    {
-      code: 'cy.submitBtn().click();',
-      parserOptions,
-    },
-  ],
-
-  invalid: [
-    {
-      code: 'cy.get("new-todo").type("todo A{enter}").should("have.class", "active");',
-      parserOptions,
-      errors,
-    },
-    {
-      code: 'cy.get("new-todo").type("todo A{enter}").type("todo B{enter}");',
-      parserOptions,
-      errors,
-    },
-    {
-      code: 'cy.get("new-todo").focus().should("have.class", "active");',
-      parserOptions,
-      errors,
-    },
-    {
-      code: 'cy.get("new-todo").customType("todo A{enter}").customClick();',
-      options: [{ methods: ['customType', 'customClick'] }],
-      parserOptions,
-      errors,
-    },
-    {
-      code: 'cy.get("new-todo").customPress("Enter").customScroll();',
-      options: [{ methods: [/customPress/, /customScroll/] }],
-      parserOptions,
-      errors,
-    },
-  ],
-})