♻️ use named args

Author: dudeofawesome

eslint-config-cli/test/index.ts

@@ -13,10 +13,10 @@ describe('eslint-config-node', () => {
 
   describe('passes', () => {
     it(`should pass radix`, async () =>
-      testNoFail(linter, `parseInt('10');\n`));
+      testNoFail({ linter, code: `parseInt('10');\n` }));
 
     it(`should pass no-console`, () =>
-      testNoFail(linter, `console.log('foo');\n`));
+      testNoFail({ linter, code: `console.log('foo');\n` }));
   });
 
   describe('fails', () => {});

eslint-config-node/test/index.ts

@@ -13,11 +13,15 @@ describe('eslint-config-node', () => {
 
   describe('passes', () => {
     it(`should pass radix`, async () =>
-      testNoFail(linter, `parseInt('10');\n`));
+      testNoFail({ linter, code: `parseInt('10');\n` }));
   });
 
   describe('fails', () => {
     it(`should fail no-console`, () =>
-      testRuleFail(linter, `console.log('foo');\n`, 'no-console'));
+      testRuleFail({
+        linter,
+        code: `console.log('foo');\n`,
+        ruleId: 'no-console',
+      }));
   });
 });

eslint-config-typescript/test/index.ts

@@ -13,22 +13,35 @@ describe('eslint-config-typescript', () => {
 
   describe('passes', () => {
     it(`should parse typescript`, () =>
-      testNoFail(linter, `((a: string): string[] => a.split(''))()\n`, true));
+      testNoFail({
+        linter,
+        code: `((a: string): string[] => a.split(''))()\n`,
+        typescript: true,
+      }));
 
     it(`should not give eslint error on use before define`, () =>
-      testNoFail(linter, `Number(a);\nconst a = 10;\n`, true));
+      testNoFail({
+        linter,
+        code: `Number(a);\nconst a = 10;\n`,
+        typescript: true,
+      }));
   });
 
   describe('fails', () => {
     it(`should fail radix`, async () =>
-      testRuleFail(linter, `parseInt('10');\n`, 'radix', true));
+      testRuleFail({
+        linter,
+        code: `parseInt('10');\n`,
+        ruleId: 'radix',
+        typescript: true,
+      }));
 
     it(`should fail @typescript-eslint/strict-boolean-expressions`, async () =>
-      testRuleFail(
+      testRuleFail({
         linter,
-        `let foo: unknown = 'foo';\nfoo = 'bar';\nif (foo) Number();\n`,
-        '@typescript-eslint/strict-boolean-expressions',
-        true,
-      ));
+        code: `let foo: unknown = 'foo';\nfoo = 'bar';\nif (foo) Number();\n`,
+        ruleId: '@typescript-eslint/strict-boolean-expressions',
+        typescript: true,
+      }));
   });
 });

eslint-config/test/index.ts

@@ -17,7 +17,7 @@ describe('eslint-config', () => {
 
   describe('fails', () => {
     it(`should fail radix`, async () =>
-      testRuleFail(linter, `parseInt('10');\n`, 'radix'));
+      testRuleFail({ linter, code: `parseInt('10');\n`, ruleId: 'radix' }));
 
     it(`should not parse typescript`, () =>
       linter

utils/testing/eslint.ts

@@ -9,29 +9,37 @@ export function filePath(typescript: boolean = false): string {
 export function defaultTestSet(linter: ESLint) {
   describe('[standard tests] passes', () => {
     it(`should parse javascript`, () =>
-      testNoFail(
+      testNoFail({
         linter,
-        `
+        code: `
 (
   /** @param {string} a */
   (a) => a.split('')
 )('test');
 `,
-      ));
+      }));
 
     it(`should allow nested ternaries`, () =>
-      testNoFail(
+      testNoFail({
         linter,
-        `(() => (Number === true ? 'a' : Boolean === true ? 'b' : 'c'))();\n`,
-        true,
-      ));
+        code: `(() => (Number === true ? 'a' : Boolean === true ? 'b' : 'c'))();\n`,
+        typescript: true,
+      }));
   });
   describe('[standard tests] fails', () => {
     it(`should fail eqeqeq`, () =>
-      testRuleFail(linter, `if (Number == true) Number();\n`, 'eqeqeq'));
+      testRuleFail({
+        linter,
+        code: `if (Number == true) Number();\n`,
+        ruleId: 'eqeqeq',
+      }));
 
     it(`should warn on prettier`, () =>
-      testRuleFail(linter, `Number( '5')`, 'prettier/prettier'));
+      testRuleFail({
+        linter,
+        code: `Number( '5')`,
+        ruleId: 'prettier/prettier',
+      }));
 
     // TODO: test for shopify rule
   });
@@ -63,27 +71,42 @@ export function singleLintMessage(lint_results: ESLint.LintResult[]) {
   );
 }
 
-export async function testRuleFail(
-  linter: ESLint,
-  code: string,
-  ruleId: string,
-  typescript: boolean = false,
-) {
+interface TestRuleFailOpts {
+  linter: ESLint;
+  code: string;
+  ruleId: string;
+  typescript?: boolean;
+  file_path?: string;
+}
+export async function testRuleFail({
+  linter,
+  code,
+  ruleId,
+  typescript = false,
+  file_path = filePath(typescript),
+}: TestRuleFailOpts) {
   const res = await linter.lintText(code, {
-    filePath: filePath(typescript),
+    filePath: file_path,
   });
   singleLintMessage(res);
   strictEqual(res[0]?.source, code);
   strictEqual(res[0]?.messages[0]?.ruleId, ruleId);
 }
 
-export async function testNoFail(
-  linter: ESLint,
-  code: string,
-  typescript: boolean = false,
-) {
+interface TestNoFailOpts {
+  linter: ESLint;
+  code: string;
+  typescript?: boolean;
+  file_path?: string;
+}
+export async function testNoFail({
+  linter,
+  code,
+  typescript = false,
+  file_path = filePath(typescript),
+}: TestNoFailOpts) {
   const res = await linter.lintText(code, {
-    filePath: filePath(typescript),
+    filePath: file_path,
   });
   noLintMessage(res);
 }