Use message ids to comply with new eslint rules

Author: DamienCassou

lib/rules/no-expect-for-stub.js

@@ -28,11 +28,10 @@ module.exports = {
     },
     fixable: 'code',
     schema: [],
+    messages: { 'message': 'Prefer cy.get("@stub").should(…) over expect(stub)…' },
   },
 
   create (context) {
-    const MESSAGE = 'Prefer cy.get("@stub").should(…) over expect(stub)…'
-
     //----------------------------------------------------------------------
     // Helpers
     //----------------------------------------------------------------------
@@ -62,7 +61,7 @@ module.exports = {
 
         context.report({
           node,
-          message: MESSAGE,
+          messageId: 'message',
           fix: (fixer) => fixCall(fixer, node, expectArgument),
         })
       },
@@ -79,7 +78,7 @@ module.exports = {
 
         context.report({
           node,
-          message: MESSAGE,
+          messageId: 'message',
           fix: (fixer) => fixCall(fixer, node, expectArgument),
         })
       },

lib/rules/no-single-expect-in-then-or-should.js

@@ -23,12 +23,13 @@ module.exports = {
     },
     fixable: 'code',
     schema: [],
+    messages: {
+      'message_then': 'A single expect() in a then() can be rewritten with a should().',
+      'message_should': 'A single expect() in a should() can be rewritten with just a should().',
+    },
   },
 
   create (context) {
-    const MESSAGE_THEN = 'A single expect() in a then() can be rewritten with a should().'
-    const MESSAGE_SHOULD = 'A single expect() in a should() can be rewritten with just a should().'
-
     //----------------------------------------------------------------------
     // Helpers
     //----------------------------------------------------------------------
@@ -48,15 +49,15 @@ module.exports = {
     }
 
     /**
-     * Report an error with `message` if both conditions are satisfied:
+     * Report an error with `messageId` if both conditions are satisfied:
      *
      * - `thenOrShouldCallNode` contains as single argument a function
      * with a lonely `expect()` statement, and
      *
      * - the `expect()` must take as argument the same object as the
      * one passed to the function.
      */
-    function checkThenOrShould (thenOrShouldCallNode, message) {
+    function checkThenOrShould (thenOrShouldCallNode, messageId) {
       if (thenOrShouldCallNode.arguments.length !== 1) return
 
       let argument = thenOrShouldCallNode.arguments[0]
@@ -95,7 +96,7 @@ module.exports = {
       if (expectArgument === anonymousFunctionArgumentName) {
         context.report({
           node: thenOrShouldCallNode,
-          message,
+          messageId,
           fix: (fixer) => fixCall(fixer, thenOrShouldCallNode, thenArgumentBody.expression),
         })
       }
@@ -111,10 +112,10 @@ module.exports = {
 
         switch (node.callee.property.name) {
           case 'then':
-            checkThenOrShould(node, MESSAGE_THEN)
+            checkThenOrShould(node, 'message_then')
             break
           case 'should':
-            checkThenOrShould(node, MESSAGE_SHOULD)
+            checkThenOrShould(node, 'message_should')
             break
           default:
             return

lib/rules/no-useless-then-or-should.js

@@ -23,11 +23,10 @@ module.exports = {
     },
     fixable: 'code', // Or `code` or `whitespace`
     schema: [],
+    messages: { 'message': '`.should()` and `.then()` can be removed when they only wrap commands' },
   },
 
   create (context) {
-    const MESSAGE = '`.should()` and `.then()` can be removed when they only wrap commands'
-
     //----------------------------------------------------------------------
     // Helpers
     //----------------------------------------------------------------------
@@ -120,7 +119,7 @@ module.exports = {
 
         if (!commandStatementsRange) return
 
-        context.report({ node, message: MESSAGE, fix: (fixer) => fixCall(fixer, node, commandStatementsRange) })
+        context.report({ node, messageId: 'message', fix: (fixer) => fixCall(fixer, node, commandStatementsRange) })
       },
     }
   },

tests/lib/rules/no-expect-for-stub.js

@@ -15,7 +15,6 @@ const RuleTester = require('eslint').RuleTester
 // Tests
 //------------------------------------------------------------------------------
 
-const MESSAGE = 'Prefer cy.get("@stub").should(…) over expect(stub)…'
 const ruleTester = new RuleTester()
 
 ruleTester.run('no-expect-for-stub', rule, {
@@ -29,22 +28,22 @@ ruleTester.run('no-expect-for-stub', rule, {
   invalid: [
     {
       code: 'expect(stub).to.have.been.calledOnce',
-      errors: [{ message: MESSAGE, type: 'MemberExpression' }],
+      errors: [{ messageId: 'message', type: 'MemberExpression' }],
       output: 'cy.get("@stub").should("have.been.calledOnce")',
     },
     {
       code: 'expect(getCellContentClickedCallback).to.have.been\n.calledTwice',
-      errors: [{ message: MESSAGE, type: 'MemberExpression' }],
+      errors: [{ messageId: 'message', type: 'MemberExpression' }],
       output: 'cy.get("@getCellContentClickedCallback").should("have.been.calledTwice")',
     },
     {
       code: 'expect(stub).to.be.calledWith(value)',
-      errors: [{ message: MESSAGE, type: 'CallExpression' }],
+      errors: [{ messageId: 'message', type: 'CallExpression' }],
       output: 'cy.get("@stub").should("be.calledWith", value)',
     },
     {
       code: 'expect(stub).to.be.calledWith()',
-      errors: [{ message: MESSAGE, type: 'CallExpression' }],
+      errors: [{ messageId: 'message', type: 'CallExpression' }],
       output: 'cy.get("@stub").should("be.calledWith")',
     },
   ],

tests/lib/rules/no-single-expect-in-then-or-should.js

@@ -15,11 +15,8 @@ const RuleTester = require('eslint').RuleTester
 // Tests
 //------------------------------------------------------------------------------
 
-const MESSAGE_THEN = 'A single expect() in a then() can be rewritten with a should().'
-const MESSAGE_SHOULD = 'A single expect() in a should() can be rewritten with just a should().'
-
-const thenError = { message: MESSAGE_THEN, type: 'CallExpression' }
-const shouldError = { message: MESSAGE_SHOULD, type: 'CallExpression' }
+const thenError = { messageId: 'message_then', type: 'CallExpression' }
+const shouldError = { messageId: 'message_should', type: 'CallExpression' }
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } })
 

tests/lib/rules/no-useless-then-or-should.js

@@ -16,8 +16,7 @@ const RuleTester = require('eslint').RuleTester
 //------------------------------------------------------------------------------
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } })
-const MESSAGE = '`.should()` and `.then()` can be removed when they only wrap commands'
-const errors = [{ message: MESSAGE, type: 'CallExpression' }]
+const errors = [{ messageId: 'message', type: 'CallExpression' }]
 
 ruleTester.run('no-useless-then-or-should', rule, {
   valid: [