Merge pull request #13 from cypress-io/issue-12-whitelist-returnable-commands

Whitelist returnable commands

Author: chrisbreiding

lib/config/recommended.js

@@ -1,9 +1,9 @@
-'use strict';
+'use strict'
 
 module.exports = {
   plugins: ['cypress'],
   rules: {
     'cypress/no-assigning-return-values': 'error',
-    'cypress/no-unnecessary-waiting': 'error'
-  }
-};
+    'cypress/no-unnecessary-waiting': 'error',
+  },
+}

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

@@ -3,47 +3,64 @@
  * @author Elad Shahar
  */
 
-'use strict';
+'use strict'
+
+// safely get nested object property
+function get (obj, propertyString = '') {
+  const properties = propertyString.split('.')
+  for (let i = 0; i < properties.length; i++) {
+    const value = (obj || {})[properties[i]]
+    if (value == null) return value
+    obj = value
+  }
+  return obj
+}
 
 module.exports = {
   meta: {
     docs: {
       description: 'Prevent assigning return values of cy calls',
       category: 'Possible Errors',
       recommended: true,
-      url: 'https://docs.cypress.io/guides/references/best-practices.html#Assigning-Return-Values'
+      url: 'https://docs.cypress.io/guides/references/best-practices.html#Assigning-Return-Values',
     },
     schema: [],
     messages: {
-      unexpected: 'Do not assign the return value of a Cypress command'
-    }
+      unexpected: 'Do not assign the return value of a Cypress command',
+    },
   },
-  create(context) {
+  create (context) {
     return {
-      VariableDeclaration(node) {
+      VariableDeclaration (node) {
         if (node.declarations.some(isCypressCommandDeclaration)) {
-          context.report({ node, messageId: 'unexpected' });
+          context.report({ node, messageId: 'unexpected' })
         }
-      }
-    };
-  }
-};
+      },
+    }
+  },
+}
 
-function isCypressCommandDeclaration(declarator) {
-  if (!declarator)             { return; }
-  if (!declarator.init)        { return; }
-  if (!declarator.init.callee) { return; }
+const whitelistedCommands = {
+  now: true,
+  spy: true,
+  state: true,
+  stub: true,
+}
 
-  let object = declarator.init.callee.object;
+function isCypressCommandDeclaration (declarator) {
+  let object = get(declarator, 'init.callee.object')
 
-  if (!object)                 { return; }
+  if (!object) return
 
   while (object.callee) {
-    object = object.callee.object;
-    if (!object) {
-      return;
-    }
+    object = object.callee.object
+
+    if (!object) return
   }
 
-  return object.name === 'cy';
+  const commandName = get(object, 'parent.property.name')
+
+  if (commandName && whitelistedCommands[commandName]) return
+
+  return object.name === 'cy'
 }

lib/rules/no-unnecessary-waiting.js

@@ -3,42 +3,42 @@
  * @author Elad Shahar
  */
 
-'use strict';
+'use strict'
 
 module.exports = {
   meta: {
     docs: {
       description: 'Prevent waiting for arbitrary time periods',
       category: 'Possible Errors',
       recommended: true,
-      url: 'https://docs.cypress.io/guides/references/best-practices.html#Unnecessary-Waiting'
+      url: 'https://docs.cypress.io/guides/references/best-practices.html#Unnecessary-Waiting',
     },
     schema: [],
     messages: {
-      unexpected: 'Do not wait for arbitrary time periods'
-    }
+      unexpected: 'Do not wait for arbitrary time periods',
+    },
   },
-  create(context) {
+  create (context) {
     return {
-      CallExpression(node) {
+      CallExpression (node) {
         if (isCallingCyWait(node) && isNumberArgument(node)) {
-          context.report({ node, messageId: 'unexpected' });
+          context.report({ node, messageId: 'unexpected' })
         }
-      }
-    };
-  }
-};
+      },
+    }
+  },
+}
 
-function isCallingCyWait(node) {
+function isCallingCyWait (node) {
   return node.callee.type === 'MemberExpression' &&
          node.callee.object.type === 'Identifier' &&
          node.callee.object.name === 'cy' &&
          node.callee.property.type === 'Identifier' &&
-         node.callee.property.name === 'wait';
+         node.callee.property.name === 'wait'
 }
 
-function isNumberArgument(node) {
+function isNumberArgument (node) {
   return node.arguments.length > 0 &&
          node.arguments[0].type === 'Literal' &&
-         typeof(node.arguments[0].value) === 'number';
+         typeof (node.arguments[0].value) === 'number'
 }

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

@@ -1,12 +1,12 @@
-"use strict";
+'use strict'
 
-const rule = require('../../../lib/rules/no-assigning-return-values');
-const RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-assigning-return-values')
+const RuleTester = require('eslint').RuleTester
 
-const ruleTester = new RuleTester();
+const ruleTester = new RuleTester()
 
-const errors = [{ messageId: 'unexpected' }];
-const parserOptions = { ecmaVersion: 6 };
+const errors = [{ messageId: 'unexpected' }]
+const parserOptions = { ecmaVersion: 6 }
 
 ruleTester.run('no-assigning-return-values', rule, {
   valid: [
@@ -15,8 +15,12 @@ ruleTester.run('no-assigning-return-values', rule, {
     { code: 'const foo = true;', parserOptions },
     { code: 'const foo = bar();', parserOptions },
     { code: 'const foo = bar().baz();', parserOptions },
+    { code: 'const spy = cy.spy();', 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: 'cy.contains("foo").click();', parserOptions },
   ],
 
   invalid: [
@@ -28,6 +32,6 @@ ruleTester.run('no-assigning-return-values', rule, {
     { code: 'let a = cy.window()', parserOptions, errors },
     { code: 'let a = cy.wait("@something")', parserOptions, errors },
 
-    { code: 'let a = cy.contains("foo").click()', parserOptions, errors }
-  ]
-});
+    { code: 'let a = cy.contains("foo").click()', parserOptions, errors },
+  ],
+})

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

@@ -1,12 +1,12 @@
-"use strict";
+'use strict'
 
-const rule = require('../../../lib/rules/no-unnecessary-waiting');
-const RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-unnecessary-waiting')
+const RuleTester = require('eslint').RuleTester
 
-const ruleTester = new RuleTester();
+const ruleTester = new RuleTester()
 
-const errors = [{ messageId: 'unexpected' }];
-const parserOptions = { ecmaVersion: 6 };
+const errors = [{ messageId: 'unexpected' }]
+const parserOptions = { ecmaVersion: 6 }
 
 ruleTester.run('no-unnecessary-waiting', rule, {
   valid: [
@@ -15,14 +15,14 @@ ruleTester.run('no-unnecessary-waiting', rule, {
     { code: 'cy.wait("@someRequest").then((xhr) => xhr)', parserOptions },
     { code: 'cy.wait(["@someRequest", "@anotherRequest"])', parserOptions },
 
-    { code: 'cy.clock(5000)', parserOptions},
+    { code: 'cy.clock(5000)', parserOptions },
     { code: 'cy.scrollTo(0, 10)', parserOptions },
-    { code: 'cy.tick(500)', parserOptions }
+    { code: 'cy.tick(500)', parserOptions },
   ],
 
   invalid: [
     { code: 'cy.wait(0)', parserOptions, errors },
     { code: 'cy.wait(100)', parserOptions, errors },
-    { code: 'cy.wait(5000)', parserOptions, errors }
-  ]
-});
+    { code: 'cy.wait(5000)', parserOptions, errors },
+  ],
+})