Update: add autofixing to test-case-property-ordering. (fixes #31)

Author: aladdin-add

lib/rules/test-case-property-ordering.js

@@ -18,7 +18,7 @@ module.exports = {
       category: 'Tests',
       recommended: false,
     },
-    fixable: null, // or "code" or "whitespace"
+    fixable: 'code',
     schema: [{
       type: 'array',
       elements: { type: 'string' },
@@ -31,29 +31,43 @@ module.exports = {
     // ----------------------------------------------------------------------
     const message = 'The properties of a test case should be placed in a consistent order: [{{order}}].';
     const order = context.options[0] || ['code', 'output', 'options', 'parserOptions', 'errors'];
+    const sourceCode = context.getSourceCode();
 
     return {
       Program (ast) {
         utils.getTestInfo(context, ast).forEach(testRun => {
           [testRun.valid, testRun.invalid].forEach(tests => {
             (tests || []).forEach(test => {
-              const keys = (test.properties || []).map(utils.getKeyName);
+              const keys = test.properties || [];
+              const keyNames = keys.map(utils.getKeyName);
 
-              for (let i = 0, lastChecked; i < keys.length; i++) {
-                const current = order.indexOf(keys[i]);
+              for (let i = 0, lastChecked; i < keyNames.length; i++) {
+                const current = order.indexOf(keyNames[i]);
 
                 // current < lastChecked to catch unordered;
                 // and lastChecked === -1 to catch extra properties before.
                 if (current > -1 && (current < lastChecked || lastChecked === -1)) {
-                  let orderMsg = order.filter(item => keys.indexOf(item) > -1);
+                  let orderMsg = order.filter(item => keyNames.indexOf(item) > -1);
                   orderMsg = orderMsg.concat(
-                    lastChecked === -1 ? keys.filter(item => order.indexOf(item) === -1) : []
+                    lastChecked === -1 ? keyNames.filter(item => order.indexOf(item) === -1) : []
                   );
 
                   context.report({
                     node: test.properties[i],
                     message,
                     data: { order: orderMsg.join(', ') },
+                    fix (fixer) {
+                      // reorder the properties and put in result array.
+                      const result = [];
+                      for (let j = 0; j < keyNames.length; j++) {
+                        const insertedIndex = orderMsg.indexOf(keyNames[j]);
+                        result[insertedIndex] = sourceCode.getText(keys[j]);
+                      }
+                      return fixer.replaceTextRange(
+                        [test.properties[0].range[0], test.properties[test.properties.length - 1].range[1]],
+                        result.join(', ')
+                      );
+                    },
                   });
                 }
                 lastChecked = current;

tests/lib/rules/test-case-property-ordering.js

@@ -71,20 +71,38 @@ ruleTester.run('test-case-property-ordering', rule, {
           ]
         });
       `,
+      output: `
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              code: "foo", output: "bar", options: ["baz"],
+            },
+          ]
+        });
+      `,
       errors: [{ message: 'The properties of a test case should be placed in a consistent order: [code, output, options].' }],
     },
     {
       code: `
-      new RuleTester().run('foo', bar, {
-        valid: [
-          {
-            env: { es6: true },
-            code: "foo",
-            output: "bar",
-            options: ["baz"],
-          },
-        ]
-      });
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              env: { es6: true },
+              code: "foo",
+              output: "bar",
+              options: ["baz"],
+            },
+          ]
+        });
+      `,
+      output: `
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              code: "foo", output: "bar", options: ["baz"], env: { es6: true },
+            },
+          ]
+        });
       `,
       errors: [{ message: 'The properties of a test case should be placed in a consistent order: [code, output, options, env].' }],
     },
@@ -101,6 +119,15 @@ ruleTester.run('test-case-property-ordering', rule, {
           ]
         });
       `,
+      output: `
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              code: "foo", output: "bar", options: ["baz"], env: { es6: true },
+            },
+          ]
+        });
+      `,
       errors: [{ message: 'The properties of a test case should be placed in a consistent order: [code, output, options, env].' }],
     },
     {
@@ -115,6 +142,15 @@ ruleTester.run('test-case-property-ordering', rule, {
           ]
         });
       `,
+      output: `
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              code: "foo", options: ["baz"], output: "bar",
+            },
+          ]
+        });
+      `,
       options: [['code', 'errors', 'options', 'output', 'parserOptions']],
       errors: [{ message: 'The properties of a test case should be placed in a consistent order: [code, options, output].' }],
     },
@@ -132,6 +168,15 @@ ruleTester.run('test-case-property-ordering', rule, {
           ]
         });
       `,
+      output: `
+        new RuleTester().run('foo', bar, {
+          valid: [
+            {
+              code: "foo", errors: ["foo"], output: "", options: ["baz"], parserOptions: "",
+            },
+          ]
+        });
+      `,
       options: [['code', 'errors', 'output']],
       errors: [{ message: 'The properties of a test case should be placed in a consistent order: [code, errors, output, options, parserOptions].' }],
     },