Merge pull request #205 from MikeMcC399/save-legacy-tests

tests: save legacy tests

Author: jennifer-shehane

circle.yml

@@ -52,7 +52,7 @@ jobs:
           command: npx eslint --version
       - run:
           name: Test ESLint 7
-          command: npm test
+          command: npm run test:legacy
 
   test-v8:
     docker:
@@ -70,7 +70,7 @@ jobs:
           command: npx eslint --version
       - run:
           name: Test ESLint 8
-          command: npm test
+          command: npm run test:legacy
 
   release:
     docker:

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.json

@@ -41,6 +41,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"
   }

tests-legacy/config.js

@@ -0,0 +1,26 @@
+/* global describe, it, expect */
+'use strict'
+
+const globals = require('globals')
+const config = require('../index.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,
+    }))
+  })
+})

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

@@ -0,0 +1,35 @@
+'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 },
+  ],
+})

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

@@ -0,0 +1,38 @@
+'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 },
+  ],
+})

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

@@ -0,0 +1,25 @@
+'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 },
+  ],
+})

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

@@ -0,0 +1,25 @@
+'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 },
+  ],
+})

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

@@ -0,0 +1,49 @@
+'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 },
+  ],
+})

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

@@ -0,0 +1,37 @@
+'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 
+    }
+  ],
+})