feat: Rename additionalAssertFunctionNames to assertFunctionNames

BREAKING CHANGE: Rename the `additionalAssertFunctionNames` option to `assertFunctionNames`. The accepted values are the same, the setting name is the only change.

Author: mskelton

src/rules/expect-expect.ts

@@ -1,24 +1,26 @@
 import { Rule } from 'eslint';
 import ESTree from 'estree';
 import { dig, isExpectCall, isTestCall } from '../utils/ast';
-import { getAdditionalAssertFunctionNames } from '../utils/misc';
 
 function isAssertionCall(
   node: ESTree.CallExpression,
-  additionalAssertFunctionNames: string[],
+  assertFunctionNames: string[],
 ) {
   return (
     isExpectCall(node) ||
-    additionalAssertFunctionNames.find((name) => dig(node.callee, name))
+    assertFunctionNames.find((name) => dig(node.callee, name))
   );
 }
 
 export default {
   create(context) {
+    const options = {
+      assertFunctionNames: [] as string[],
+      ...((context.options?.[0] as Record<string, unknown>) ?? {}),
+    };
+
     const sourceCode = context.sourceCode ?? context.getSourceCode();
     const unchecked: ESTree.CallExpression[] = [];
-    const additionalAssertFunctionNames =
-      getAdditionalAssertFunctionNames(context);
 
     function checkExpressions(nodes: ESTree.Node[]) {
       for (const node of nodes) {
@@ -36,7 +38,7 @@ export default {
       CallExpression(node) {
         if (isTestCall(node, ['fixme', 'only', 'skip'])) {
           unchecked.push(node);
-        } else if (isAssertionCall(node, additionalAssertFunctionNames)) {
+        } else if (isAssertionCall(node, options.assertFunctionNames)) {
           const ancestors = sourceCode.getAncestors
             ? sourceCode.getAncestors(node)
             : context.getAncestors();
@@ -65,7 +67,7 @@ export default {
       {
         additionalProperties: false,
         properties: {
-          additionalAssertFunctionNames: {
+          assertFunctionNames: {
             items: [{ type: 'string' }],
             type: 'array',
           },

src/utils/misc.ts

@@ -1,24 +1,4 @@
-import { Rule } from 'eslint';
-import { Settings } from './types';
-
 export const getAmountData = (amount: number) => ({
   amount: amount.toString(),
   s: amount === 1 ? '' : 's',
 });
-
-interface AssertFunctionNamesOptions {
-  additionalAssertFunctionNames?: string[];
-}
-
-export function getAdditionalAssertFunctionNames(
-  context: Rule.RuleContext,
-): string[] {
-  const globalSettings =
-    (context.settings as Settings).playwright?.additionalAssertFunctionNames ??
-    ([] as string[]);
-  const ruleSettings =
-    (context.options[0] as AssertFunctionNamesOptions | undefined)
-      ?.additionalAssertFunctionNames ?? ([] as string[]);
-
-  return [...globalSettings, ...ruleSettings];
-}

src/utils/types.ts

@@ -15,6 +15,9 @@ export type KnownCallExpression = ESTree.CallExpression & {
 
 export interface Settings {
   playwright?: {
-    additionalAssertFunctionNames?: readonly string[];
+    globalAliases?: {
+      expect?: string[];
+      test?: string[];
+    };
   };
 }

test/spec/expect-expect.spec.ts

@@ -27,41 +27,8 @@ runRuleTester('expect-expect', rule, {
         })
       `,
       errors: [{ messageId: 'noAssertions' }],
-      name: 'Global settings no false positives',
-      settings: {
-        playwright: {
-          additionalAssertFunctionNames: ['wayComplexCustomCondition'],
-        },
-      },
-    },
-    {
-      code: dedent`
-        test('should fail', async ({ page }) => {
-          await assertCustomCondition(page)
-        })
-      `,
-      errors: [{ messageId: 'noAssertions' }],
-      name: 'Rule settings no false positives',
-      options: [
-        { additionalAssertFunctionNames: ['wayComplexCustomCondition'] },
-      ],
-    },
-    {
-      code: dedent`
-        test('should fail', async ({ page }) => {
-          await assertCustomCondition(page)
-        })
-      `,
-      errors: [{ messageId: 'noAssertions' }],
-      name: 'Global settings no false positives',
-      options: [
-        { additionalAssertFunctionNames: ['wayComplexRuleCustomCondition'] },
-      ],
-      settings: {
-        playwright: {
-          additionalAssertFunctionNames: ['wayComplexGlobalCustomCondition'],
-        },
-      },
+      name: 'Custom assert function',
+      options: [{ assertFunctionNames: ['wayComplexCustomCondition'] }],
     },
   ],
   valid: [
@@ -94,11 +61,7 @@ runRuleTester('expect-expect', rule, {
         })
       `,
       name: 'Custom assert function',
-      settings: {
-        playwright: {
-          additionalAssertFunctionNames: ['assertCustomCondition'],
-        },
-      },
+      options: [{ assertFunctionNames: ['assertCustomCondition'] }],
     },
     {
       code: dedent`
@@ -107,40 +70,7 @@ runRuleTester('expect-expect', rule, {
         })
       `,
       name: 'Custom assert class method',
-      settings: {
-        playwright: {
-          additionalAssertFunctionNames: ['assertCustomCondition'],
-        },
-      },
-    },
-    {
-      code: dedent`
-        test('should fail', async ({ page }) => {
-          await assertCustomCondition(page)
-        })
-      `,
-      name: 'Rule settings only',
-      options: [{ additionalAssertFunctionNames: ['assertCustomCondition'] }],
-    },
-    {
-      code: dedent`
-        test('should fail', async ({ page }) => {
-          await assertCustomCondition(page)
-        })
-
-        test('complex failure', async ({ page }) => {
-          await wayComplexCustomCondition(page)
-        })
-      `,
-      name: 'Global and rule settings combine rather than override',
-      options: [
-        { additionalAssertFunctionNames: ['wayComplexCustomCondition'] },
-      ],
-      settings: {
-        playwright: {
-          additionalAssertFunctionNames: ['assertCustomCondition'],
-        },
-      },
+      options: [{ assertFunctionNames: ['assertCustomCondition'] }],
     },
   ],
 });