eslint-plugin-cypress 4.3.0 → 5.0.1

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

@@ -2,30 +2,30 @@
  * @fileoverview disallow chain of `cy.get()` calls
  * @author benoit
  */
-"use strict";
+'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Requirements
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
-const rule = require("../../../lib/rules/no-chained-get"),
-  RuleTester = require("eslint").RuleTester;
+const rule = require('../../../lib/rules/no-chained-get'),
+  RuleTester = require('eslint').RuleTester
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Tests
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester();
-ruleTester.run("no-chained-get", rule, {
+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')" },
+    { 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" }],
+      code: 'cy.get(\'div\').get(\'div\')',
+      errors: [{ messageId: 'unexpected' }],
     },
   ],
-});
+})

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

@@ -10,14 +10,14 @@ const errors = [{ messageId: 'unexpected' }]
 ruleTester.run('no-debug', rule, {
 
   valid: [
-    { code: `debug()` },
-    { code: `cy.get('button').dblclick()` },
+    { code: 'debug()' },
+    { code: 'cy.get(\'button\').dblclick()' },
   ],
 
   invalid: [
-    { code: `cy.debug()`, errors },
-    { code: `cy.debug({ log: false })`, errors },
-    { code: `cy.get('button').debug()`, errors },
-    { code: `cy.get('a').should('have.attr', 'href').and('match', /dashboard/).debug()`, errors }
+    { code: 'cy.debug()', errors },
+    { code: 'cy.debug({ log: false })', errors },
+    { code: 'cy.get(\'button\').debug()', errors },
+    { code: 'cy.get(\'a\').should(\'have.attr\', \'href\').and(\'match\', /dashboard/).debug()', errors },
   ],
 })

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

@@ -10,30 +10,30 @@ const errors = [{ messageId: 'unexpected' }]
 ruleTester.run('no-force', rule, {
 
   valid: [
-    { code: `cy.get('button').click()` },
-    { code: `cy.get('button').click({multiple: true})` },
-    { code: `cy.get('button').dblclick()` },
-    { code: `cy.get('input').type('somth')` },
-    { code: `cy.get('input').type('somth', {anyoption: true})` },
-    { code: `cy.get('input').trigger('click', {anyoption: true})` },
-    { code: `cy.get('input').rightclick({anyoption: true})` },
-    { code: `cy.get('input').check()` },
-    { code: `cy.get('input').select()` },
-    { code: `cy.get('input').focus()` },
-    { code: `cy.document().trigger("keydown", { ...event })` },
+    { code: 'cy.get(\'button\').click()' },
+    { code: 'cy.get(\'button\').click({multiple: true})' },
+    { code: 'cy.get(\'button\').dblclick()' },
+    { code: 'cy.get(\'input\').type(\'somth\')' },
+    { code: 'cy.get(\'input\').type(\'somth\', {anyoption: true})' },
+    { code: 'cy.get(\'input\').trigger(\'click\', {anyoption: true})' },
+    { code: 'cy.get(\'input\').rightclick({anyoption: true})' },
+    { code: 'cy.get(\'input\').check()' },
+    { code: 'cy.get(\'input\').select()' },
+    { code: 'cy.get(\'input\').focus()' },
+    { code: 'cy.document().trigger("keydown", { ...event })' },
   ],
 
   invalid: [
-    { code: `cy.get('button').click({force: true})`, errors },
-    { code: `cy.get('button').dblclick({force: true})`, errors },
-    { code: `cy.get('input').type('somth', {force: true})`, errors },
-    { code: `cy.get('div').find('.foo').type('somth', {force: true})`, errors },
-    { code: `cy.get('div').find('.foo').find('.bar').click({force: true})`, errors },
-    { code: `cy.get('div').find('.foo').find('.bar').trigger('change', {force: true})`, errors },
-    { code: `cy.get('input').trigger('click', {force: true})`, errors },
-    { code: `cy.get('input').rightclick({force: true})`, errors },
-    { code: `cy.get('input').check({force: true})`, errors },
-    { code: `cy.get('input').select({force: true})`, errors },
-    { code: `cy.get('input').focus({force: true})`, errors },
+    { code: 'cy.get(\'button\').click({force: true})', errors },
+    { code: 'cy.get(\'button\').dblclick({force: true})', errors },
+    { code: 'cy.get(\'input\').type(\'somth\', {force: true})', errors },
+    { code: 'cy.get(\'div\').find(\'.foo\').type(\'somth\', {force: true})', errors },
+    { code: 'cy.get(\'div\').find(\'.foo\').find(\'.bar\').click({force: true})', errors },
+    { code: 'cy.get(\'div\').find(\'.foo\').find(\'.bar\').trigger(\'change\', {force: true})', errors },
+    { code: 'cy.get(\'input\').trigger(\'click\', {force: true})', errors },
+    { code: 'cy.get(\'input\').rightclick({force: true})', errors },
+    { code: 'cy.get(\'input\').check({force: true})', errors },
+    { code: 'cy.get(\'input\').select({force: true})', errors },
+    { code: 'cy.get(\'input\').focus({force: true})', errors },
   ],
 })

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

@@ -10,14 +10,14 @@ const errors = [{ messageId: 'unexpected' }]
 ruleTester.run('no-pause', rule, {
 
   valid: [
-    { code: `pause()` },
-    { code: `cy.get('button').dblclick()` },
+    { code: 'pause()' },
+    { code: 'cy.get(\'button\').dblclick()' },
   ],
 
   invalid: [
-    { code: `cy.pause()`, errors },
-    { code: `cy.pause({ log: false })`, errors },
-    { code: `cy.get('button').pause()`, errors },
-    { code: `cy.get('a').should('have.attr', 'href').and('match', /dashboard/).pause()`, errors }
+    { code: 'cy.pause()', errors },
+    { code: 'cy.pause({ log: false })', errors },
+    { code: 'cy.get(\'button\').pause()', errors },
+    { code: 'cy.get(\'a\').should(\'have.attr\', \'href\').and(\'match\', /dashboard/).pause()', errors },
   ],
 })

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

@@ -1,30 +1,30 @@
-"use strict";
+'use strict'
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Requirements
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
-const rule = require("../../../lib/rules/no-xpath"),
-  RuleTester = require("eslint").RuleTester;
+const rule = require('../../../lib/rules/no-xpath'),
+  RuleTester = require('eslint').RuleTester
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 // Tests
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester();
-ruleTester.run("no-xpath", rule, {
+const ruleTester = new RuleTester()
+ruleTester.run('no-xpath', rule, {
   valid: [
     { code: 'cy.get("button").click({force: true})' },
   ],
 
   invalid: [
     {
-      code: "cy.xpath('//div[@class=\"container\"]/p[1]').click()",
-      errors: [{ messageId: "unexpected" }],
+      code: 'cy.xpath(\'//div[@class="container"]/p[1]\').click()',
+      errors: [{ messageId: 'unexpected' }],
     },
     {
-      code: "cy.xpath('//p[1]').should('exist')",
-      errors: [{ messageId: "unexpected" }]
-    }
+      code: 'cy.xpath(\'//p[1]\').should(\'exist\')',
+      errors: [{ messageId: 'unexpected' }],
+    },
   ],
-});
+})

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

@@ -10,7 +10,7 @@ const errors = [{ messageId: 'unexpected' }]
 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");'
+      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");',
     },
     { code: 'cy.focused().should("be.visible");' },
     { code: 'cy.submitBtn().click();' },

package/vitest.config.mts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['**/tests/**/*.[jt]s?(x)'],
+    globals: true
+  },
+})

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/jest.config.js

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

package/legacy.js

@@ -1,36 +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'),
-    'no-chained-get': require('./lib/rules/no-chained-get'),
-  },
-  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
-  ],
-})