make explicit test options & deduplicate

Author: zachbryant

src/report.ts

@@ -60,6 +60,15 @@ export function reportBodyNodes(
       assert(loc, 'createReportObject return value must include a node location')
       assert(messageId, 'createReportObject return value must include a problem message')
 
+      let optionsString = [
+        isRequiredFirst && 'required-first',
+        isInsensitive && 'insensitive',
+        isNatural && 'natural',
+      ]
+        .filter(Boolean)
+        .join(', ')
+      if (optionsString) optionsString += ' '
+
       context.report({
         loc,
         messageId,
@@ -71,9 +80,7 @@ export function reportBodyNodes(
               ? `before '${getPropertyName(sortedBody[finalIndex + 1])}'`
               : 'at the end',
           order,
-          insensitive: isInsensitive ? 'insensitive ' : '',
-          natural: isNatural ? 'natural ' : '',
-          requiredFirst: isRequiredFirst ? 'required first ' : '',
+          options: optionsString,
           notice: getDeprecationMessage(context.id),
         },
         fix: fixerFunction,

src/types/error.ts

@@ -1,6 +1,6 @@
 export enum ErrorMessage {
   InterfaceParentInvalidOrder = `Found {{ unsortedCount }} keys out of order.`,
   EnumParentInvalidOrder = `{{ notice }}Found {{ unsortedCount }} members out of order.`,
-  InterfaceInvalidOrder = `Expected interface keys to be in {{ requiredFirst }}{{ insensitive }}{{ natural }}{{ order }}ending order. '{{ nodeName }}' should be {{ messageShouldBeWhere }}. Run autofix to sort entire body.`,
-  EnumInvalidOrder = `{{ notice }}Expected enum members to be in {{ insensitive }}{{ natural }}{{ order }}ending order. '{{ nodeName }}' should be {{ messageShouldBeWhere }}. Run autofix to sort entire body.`,
+  InterfaceInvalidOrder = `Expected interface keys to be in {{ order }}ending {{ options }}order. '{{ nodeName }}' should be {{ messageShouldBeWhere }}. Run autofix to sort entire body.`,
+  EnumInvalidOrder = `{{ notice }}Expected enum members to be in {{ order }}ending {{ options }}order. '{{ nodeName }}' should be {{ messageShouldBeWhere }}. Run autofix to sort entire body.`,
 }

tests/helpers/options.ts

@@ -1,4 +1,4 @@
-import { AllRuleOptions, SortingOrder, SortingParamsOptions } from 'types'
+import { AllRuleOptions, SortingOrder, SortingParamsOptions } from '../../src/types'
 
 export type OptionsSet = {
   /**
@@ -10,84 +10,74 @@ export type OptionsSet = {
  * Option sets by test category
  */
 export const optionsSetsWithRequiredFirst = {
-  ascendingOnly: [[SortingOrder.Ascending]],
-  ascending: [
-    [],
-    [SortingOrder.Ascending],
-    [SortingOrder.Ascending, { caseSensitive: true }],
-    [SortingOrder.Ascending, { natural: false }],
-    [SortingOrder.Ascending, { caseSensitive: true, natural: false }],
+  ascendingWithDefaults: [[], [SortingOrder.Ascending]],
+  ascendingSensitiveNonNaturalNotRequired: [
     [
       SortingOrder.Ascending,
       { caseSensitive: true, natural: false, requiredFirst: false },
     ],
   ],
-  ascendingInsensitive: [[SortingOrder.Ascending, { caseSensitive: false }]],
-  ascendingNatural: [[SortingOrder.Ascending, { natural: true }]],
-  ascendingInsensitiveNatural: [
-    [SortingOrder.Ascending, { natural: true, caseSensitive: false }],
+  ascendingInsensitiveNonNaturalNotRequired: [
+    [
+      SortingOrder.Ascending,
+      { caseSensitive: false, natural: false, requiredFirst: false },
+    ],
   ],
-  ascendingSensitive: [
-    [],
-    [SortingOrder.Ascending],
-    [SortingOrder.Ascending, { caseSensitive: true }],
-    [SortingOrder.Ascending, { natural: false }],
-    [SortingOrder.Ascending, { caseSensitive: true, natural: false }],
+  ascendingSensitiveNaturalNotRequired: [
     [
       SortingOrder.Ascending,
-      { caseSensitive: true, natural: false, requiredFirst: false },
+      { caseSensitive: true, natural: true, requiredFirst: false },
+    ],
+  ],
+  ascendingInsensitiveNaturalNotRequired: [
+    [
+      SortingOrder.Ascending,
+      { caseSensitive: false, natural: true, requiredFirst: false },
     ],
   ],
   ascendingInsensitiveNaturalRequired: [
     [
       SortingOrder.Ascending,
-      { natural: true, caseSensitive: false, requiredFirst: true },
+      { caseSensitive: false, natural: true, requiredFirst: true },
     ],
   ],
-  ascendingInsensitiveNaturalNotRequired: [
+  ascendingSensitiveNonNaturalRequired: [
     [
       SortingOrder.Ascending,
-      { natural: true, caseSensitive: false, requiredFirst: false },
+      { caseSensitive: true, natural: false, requiredFirst: true },
     ],
   ],
-  ascendingRequired: [[SortingOrder.Ascending, { requiredFirst: true }]],
-  descendingOnly: [[SortingOrder.Descending]],
-  descending: [
-    [SortingOrder.Descending],
-    [SortingOrder.Descending, { caseSensitive: true }],
-    [SortingOrder.Descending, { natural: false }],
-    [SortingOrder.Descending, { caseSensitive: true, natural: false }],
+  descendingWithDefaults: [[SortingOrder.Descending]],
+  descendingInsensitiveNonNaturalNotRequired: [
     [
       SortingOrder.Descending,
-      { caseSensitive: true, natural: false, requiredFirst: false },
+      { caseSensitive: false, natural: false, requiredFirst: false },
     ],
   ],
-  descendingInsensitive: [[SortingOrder.Descending, { caseSensitive: false }]],
-  descendingInsensitiveNonNatural: [
-    [SortingOrder.Descending, { caseSensitive: false }],
-    [SortingOrder.Descending, { caseSensitive: false, natural: false }],
-  ],
-  descendingNatural: [[SortingOrder.Descending, { natural: true }]],
-  descendingInsensitiveNatural: [
-    [SortingOrder.Descending, { natural: true, caseSensitive: false }],
+  descendingSensitiveNaturalNotRequired: [
+    [
+      SortingOrder.Descending,
+      { caseSensitive: true, natural: true, requiredFirst: false },
+    ],
   ],
-  descendingSensitiveNatural: [
-    [SortingOrder.Descending, { natural: true }],
-    [SortingOrder.Descending, { natural: true, caseSensitive: true }],
+  descendingInsensitiveNaturalNotRequired: [
+    [
+      SortingOrder.Descending,
+      { caseSensitive: false, natural: true, requiredFirst: false },
+    ],
   ],
   descendingInsensitiveNaturalRequired: [
     [
       SortingOrder.Descending,
-      { natural: true, caseSensitive: false, requiredFirst: true },
+      { caseSensitive: false, natural: true, requiredFirst: true },
     ],
   ],
-  descendingInsensitiveNaturalNotRequired: [
+  descendingSensitiveNonNaturalRequired: [
     [
       SortingOrder.Descending,
-      { natural: true, caseSensitive: false, requiredFirst: false },
+      { caseSensitive: false, natural: true, requiredFirst: true },
     ],
   ],
-  descendingRequired: [[SortingOrder.Descending, { requiredFirst: true }]],
   noOptions: [[]],
 }
 

tests/helpers/strings.ts

@@ -1,26 +1,23 @@
 import { OptionsSetsKey } from './options'
 
+// Check src/report.ts for option string ordering
+// Only options set differently from default are printed
 export const orderStrings: Record<OptionsSetsKey, string> = {
-  ascending: 'ascending',
-  ascendingInsensitive: 'insensitive ascending',
-  ascendingNatural: 'natural ascending',
-  ascendingInsensitiveNatural: 'insensitive natural ascending',
-  descendingOnly: 'descending',
-  descendingInsensitive: 'insensitive descending',
-  descendingNatural: 'natural descending',
-  descendingInsensitiveNatural: 'insensitive natural descending',
-  noOptions: '',
-  ascendingOnly: 'ascending',
-  ascendingSensitive: 'ascending',
-  ascendingInsensitiveNaturalRequired: 'required first insensitive natural ascending',
-  ascendingInsensitiveNaturalNotRequired: 'insensitive natural ascending',
-  ascendingRequired: '',
-  descending: 'descending',
-  descendingInsensitiveNonNatural: '',
-  descendingSensitiveNatural: '',
-  descendingInsensitiveNaturalRequired: 'required first insensitive natural descending',
-  descendingInsensitiveNaturalNotRequired: 'insensitive natural descending',
-  descendingRequired: '',
+  ascendingInsensitiveNaturalNotRequired: 'ascending insensitive, natural',
+  ascendingInsensitiveNaturalRequired: 'ascending required-first, insensitive, natural',
+  ascendingInsensitiveNonNaturalNotRequired: 'ascending insensitive',
+  ascendingSensitiveNaturalNotRequired: 'ascending natural',
+  ascendingSensitiveNonNaturalNotRequired: 'ascending',
+  ascendingSensitiveNonNaturalRequired: 'ascending required-first',
+  ascendingWithDefaults: 'ascending',
+  noOptions: 'ascending',
+
+  descendingInsensitiveNaturalNotRequired: 'descending insensitive, natural',
+  descendingInsensitiveNaturalRequired: 'descending required-first, insensitive, natural',
+  descendingInsensitiveNonNaturalNotRequired: 'descending insensitive',
+  descendingSensitiveNaturalNotRequired: 'descending natural',
+  descendingSensitiveNonNaturalRequired: 'descending required-first',
+  descendingWithDefaults: 'descending',
 }
 
 export enum CaseCategory {

tests/rules/enum/enum-big.spec.ts

@@ -17,11 +17,11 @@ const invalidBigTestCode = fs
   .toString('utf-8')
 
 const valid: PreValidTestCaseObject = {
-  ascending: [validBigTestCode],
+  ascendingWithDefaults: [validBigTestCode],
 }
 
 const invalid: PreInvalidTestCaseObject = {
-  ascending: [
+  ascendingWithDefaults: [
     {
       code: invalidBigTestCode,
       output: validBigTestCode,