@checkdigit/eslint-plugin 6.6.0-PR.75-b2d2 → 6.6.0-PR.75-1cd1

package/src/no-fixture.ts

@@ -6,8 +6,6 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-/* eslint-disable no-console */
-
 import type {
   AwaitExpression,
   CallExpression,
@@ -18,8 +16,8 @@ import type {
   SimpleCallExpression,
   VariableDeclaration,
 } from 'estree';
-import type { Rule, Scope, SourceCode } from 'eslint';
-import { getAncestor, getParent } from './ast/tree';
+import { type Rule, type Scope, SourceCode } from 'eslint';
+import { getEnclosingScopeNode, getEnclosingStatement, getParent } from './ast/tree';
 import { strict as assert } from 'node:assert';
 import getDocumentationUrl from './get-documentation-url';
 import { getIndentation } from './ast/format';
@@ -33,10 +31,12 @@ interface FixtureCallInformation {
   requestBody?: Expression;
   requestHeaders?: { name: Expression; value: Expression }[];
   assertions?: Expression[][];
+  inlineStatementNode?: Node;
+  inlineBodyReference?: MemberExpression;
 }
 
 // recursively analyze the fixture/supertest call chain to collect information of request/response
-function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInformation) {
+function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInformation, sourceCode: SourceCode) {
   const parent = getParent(call);
   assert.ok(parent, 'parent should exist for fixture/supertest call node');
 
@@ -47,11 +47,18 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
     results.rootNode = parent;
   } else if (parent.type === 'AwaitExpression') {
     results.fixtureNode = call;
-    // [TODO:] should we consider variable declaration without await??
-    const variableDeclaration = getAncestor(parent, 'VariableDeclaration', 'FunctionDeclaration');
-    if (variableDeclaration?.type === 'VariableDeclaration') {
-      results.variableDeclaration = variableDeclaration;
-      results.rootNode = variableDeclaration;
+    const enclosingStatement = getEnclosingStatement(parent);
+    assert.ok(enclosingStatement);
+    const awaitParent = getParent(parent);
+    if (awaitParent?.type === 'MemberExpression') {
+      results.rootNode = parent;
+      results.inlineStatementNode = enclosingStatement;
+      if (awaitParent.property.type === 'Identifier' && awaitParent.property.name === 'body') {
+        results.inlineBodyReference = awaitParent;
+      }
+    } else if (enclosingStatement.type === 'VariableDeclaration') {
+      results.variableDeclaration = enclosingStatement;
+      results.rootNode = enclosingStatement;
     } else {
       results.rootNode = parent;
     }
@@ -77,10 +84,10 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
       nextCall = setRequestHeaderCall;
     }
   } else {
-    throw new Error(`Unexpected expression in fixture/supertest call ${String(parent)}`);
+    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}`);
   }
   if (nextCall) {
-    analyzeFixtureCall(nextCall, results);
+    analyzeFixtureCall(nextCall, results, sourceCode);
   }
 }
 
@@ -91,8 +98,9 @@ function analyzeResponseReferences(fixtureInformation: FixtureCallInformation, s
     bodyReferences: MemberExpression[];
     headersReferences: MemberExpression[];
     statusReferences: MemberExpression[];
-    spreadBodyVariable?: Scope.Variable;
-    spreadHeadersVariable?: Scope.Variable;
+    destructuringBodyVariable?: Scope.Variable;
+    destructuringHeadersVariable?: Scope.Variable;
+    destructuringHeadersReferences?: MemberExpression[] | undefined;
   } = {
     bodyReferences: [],
     headersReferences: [],
@@ -102,6 +110,7 @@ function analyzeResponseReferences(fixtureInformation: FixtureCallInformation, s
   if (fixtureInformation.variableDeclaration) {
     const responseVariables = scopeManager.getDeclaredVariables(fixtureInformation.variableDeclaration);
     for (const responseVariable of responseVariables) {
+      const scope = responseVariable.scope;
       const identifier = responseVariable.identifiers[0];
       assert.ok(identifier);
       const identifierParent = getParent(identifier);
@@ -109,53 +118,61 @@ function analyzeResponseReferences(fixtureInformation: FixtureCallInformation, s
       if (identifierParent.type === 'VariableDeclarator') {
         // e.g. const response = ...
         results.variable = responseVariable;
+        const responseReferences = responseVariable.references.map((responseReference) =>
+          getParent(responseReference.identifier),
+        );
         // e.g. response.body
-        results.bodyReferences = responseVariable.references
-          .map((responseBodyReference) => getParent(responseBodyReference.identifier))
-          .filter(
-            (node): node is MemberExpression =>
-              node !== null &&
-              node !== undefined &&
-              node.type === 'MemberExpression' &&
-              node.property.type === 'Identifier' &&
-              node.property.name === 'body',
-          );
+        results.bodyReferences = responseReferences.filter(
+          (node): node is MemberExpression =>
+            node !== null &&
+            node !== undefined &&
+            node.type === 'MemberExpression' &&
+            node.property.type === 'Identifier' &&
+            node.property.name === 'body',
+        );
         // e.g. response.headers / response.header / response.get()
-        results.headersReferences = responseVariable.references
-          .map((responseHeadersReference) => getParent(responseHeadersReference.identifier))
-          .filter(
-            (node): node is MemberExpression =>
-              node !== null &&
-              node !== undefined &&
-              node.type === 'MemberExpression' &&
-              node.property.type === 'Identifier' &&
-              (node.property.name === 'header' || node.property.name === 'headers' || node.property.name === 'get'),
-          );
+        results.headersReferences = responseReferences.filter(
+          (node): node is MemberExpression =>
+            node !== null &&
+            node !== undefined &&
+            node.type === 'MemberExpression' &&
+            node.property.type === 'Identifier' &&
+            (node.property.name === 'header' || node.property.name === 'headers' || node.property.name === 'get'),
+        );
         // e.g. response.status / response.statusCode
-        results.statusReferences = responseVariable.references
-          .map((responseHeadersReference) => getParent(responseHeadersReference.identifier))
-          .filter(
-            (node): node is MemberExpression =>
-              node !== null &&
-              node !== undefined &&
-              node.type === 'MemberExpression' &&
-              node.property.type === 'Identifier' &&
-              (node.property.name === 'status' || node.property.name === 'statusCode'),
-          );
+        results.statusReferences = responseReferences.filter(
+          (node): node is MemberExpression =>
+            node !== null &&
+            node !== undefined &&
+            node.type === 'MemberExpression' &&
+            node.property.type === 'Identifier' &&
+            (node.property.name === 'status' || node.property.name === 'statusCode'),
+        );
       } else if (
         // body reference through destruction/renaming, e.g. "const { body } = ..."
         identifierParent.type === 'Property' &&
         identifierParent.key.type === 'Identifier' &&
         identifierParent.key.name === 'body'
       ) {
-        results.spreadBodyVariable = responseVariable;
+        results.destructuringBodyVariable = responseVariable;
       } else if (
         // header reference through destruction/renaming, e.g. "const { headers } = ..."
         identifierParent.type === 'Property' &&
         identifierParent.key.type === 'Identifier' &&
         identifierParent.key.name === 'headers'
       ) {
-        results.spreadHeadersVariable = responseVariable;
+        results.destructuringHeadersVariable = responseVariable;
+        results.destructuringHeadersReferences = scope.set
+          .get(responseVariable.name)
+          ?.references.map((reference) => reference.identifier)
+          .map(getParent)
+          .filter(
+            (parent): parent is MemberExpression =>
+              parent?.type === 'MemberExpression' &&
+              parent.property.type === 'Identifier' &&
+              parent.property.name !== 'get' &&
+              getParent(parent)?.type !== 'CallExpression',
+          );
       } else {
         throw new Error(`Unknown response variable reference: ${responseVariable.name}`);
       }
@@ -174,12 +191,13 @@ function isValidPropertyName(name: unknown) {
   return typeof name === 'string' && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/u.test(name);
 }
 
+// eslint-disable-next-line sonarjs/cognitive-complexity
 function createResponseAssertions(
   fixtureCallInformation: FixtureCallInformation,
   sourceCode: SourceCode,
-  variableName: string,
+  responseVariableName: string,
+  destructuringResponseHeadersVariable: Scope.Variable | undefined,
 ) {
-  // [TODO:] make sure status assertion is ordered as the first
   let statusAssertion: string | undefined;
   const nonStatusAssertions: string[] = [];
   for (const expectArguments of fixtureCallInformation.assertions ?? []) {
@@ -190,20 +208,32 @@ function createResponseAssertions(
         (assertionArgument.type === 'MemberExpression' &&
           assertionArgument.object.type === 'Identifier' &&
           assertionArgument.object.name === 'StatusCodes') ||
-        assertionArgument.type === 'Literal'
+        assertionArgument.type === 'Literal' ||
+        sourceCode.getText(assertionArgument).includes('StatusCodes.')
       ) {
         // status code assertion
-        statusAssertion = `assert.equal(${variableName}.status, ${sourceCode.getText(assertionArgument)})`;
+        statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
       } else if (assertionArgument.type === 'ArrowFunctionExpression') {
-        // callback assertion
-        nonStatusAssertions.push(`assert.ok(${sourceCode.getText(assertionArgument)})`);
+        // callback assertion using arrow function
+        let functionBody = sourceCode.getText(assertionArgument.body);
+
+        const [originalResponseArgument] = assertionArgument.params;
+        assert.ok(originalResponseArgument?.type === 'Identifier');
+        const originalResponseArgumentName = originalResponseArgument.name;
+        if (originalResponseArgumentName !== responseVariableName) {
+          functionBody = functionBody.replace(
+            new RegExp(`\\b${originalResponseArgumentName}\\b`, 'ug'),
+            responseVariableName,
+          );
+        }
+        nonStatusAssertions.push(`assert.ok(${functionBody})`);
       } else if (assertionArgument.type === 'Identifier') {
-        // callback assertion
-        nonStatusAssertions.push(`assert.ok(${sourceCode.getText(assertionArgument)}(${variableName}))`);
+        // callback assertion using function reference
+        nonStatusAssertions.push(`assert.ok(${sourceCode.getText(assertionArgument)}(${responseVariableName}))`);
       } else if (assertionArgument.type === 'ObjectExpression' || assertionArgument.type === 'CallExpression') {
         // body deep equal assertion
         nonStatusAssertions.push(
-          `assert.deepEqual(await ${variableName}.json(), ${sourceCode.getText(assertionArgument)})`,
+          `assert.deepEqual(await ${responseVariableName}.json(), ${sourceCode.getText(assertionArgument)})`,
         );
       } else {
         throw new Error(`Unexpected Supertest assertion argument: ".expect(${sourceCode.getText(assertionArgument)})`);
@@ -212,13 +242,17 @@ function createResponseAssertions(
       // header assertion
       const [headerName, headerValue] = expectArguments;
       assert.ok(headerName && headerValue);
+      const headersReference =
+        destructuringResponseHeadersVariable !== undefined
+          ? destructuringResponseHeadersVariable.name
+          : `${responseVariableName}.headers`;
       if (headerValue.type === 'Literal' && headerValue.value instanceof RegExp) {
         nonStatusAssertions.push(
-          `assert.ok(${variableName}.headers.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`,
+          `assert.ok(${headersReference}.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`,
         );
       } else {
         nonStatusAssertions.push(
-          `assert.equal(${variableName}.headers.get(${sourceCode.getText(headerName)}), ${sourceCode.getText(headerValue)})`,
+          `assert.equal(${headersReference}.get(${sourceCode.getText(headerName)}), ${sourceCode.getText(headerValue)})`,
         );
       }
     }
@@ -236,18 +270,15 @@ function getResponseVariableNameToUse(
 ) {
   if (fixtureCallInformation.variableDeclaration) {
     const firstDeclaration = fixtureCallInformation.variableDeclaration.declarations[0];
-    // [TODO:] double check if it works for destruction/rename declaration
     if (firstDeclaration && firstDeclaration.id.type === 'Identifier') {
       return firstDeclaration.id.name;
     }
   }
 
-  const closestFunctionExpression = getAncestor(fixtureCallInformation.rootNode, (node: Node) =>
-    ['FunctionExpression', 'ArrowFunctionExpression'].includes(node.type),
-  );
-  scopeManager.getDeclaredVariables(fixtureCallInformation.rootNode); /*?*/
-  assert.ok(closestFunctionExpression);
-  const scope = scopeManager.acquire(closestFunctionExpression);
+  const enclosingScopeNode = getEnclosingScopeNode(fixtureCallInformation.rootNode);
+  scopeManager.getDeclaredVariables(fixtureCallInformation.rootNode);
+  assert.ok(enclosingScopeNode);
+  const scope = scopeManager.acquire(enclosingScopeNode);
   assert.ok(scope !== null);
   let scopeVariables = scopeVariablesMap.get(scope);
   if (!scopeVariables) {
@@ -268,6 +299,15 @@ function getResponseVariableNameToUse(
   return responseVariableNameToUse;
 }
 
+function isResponseBodyRedefinition(responseBodyReference: MemberExpression): boolean {
+  const parent = getParent(responseBodyReference);
+  return parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier';
+}
+
+function getResponseBodyRetrievalText(responseVariableName: string) {
+  return `await ${responseVariableName}.json()`;
+}
+
 const rule: Rule.RuleModule = {
   meta: {
     type: 'suggestion',
@@ -278,17 +318,19 @@ const rule: Rule.RuleModule = {
     messages: {
       preferNativeFetch: 'Prefer native fetch API over customized fixture API.',
       unknownError:
-        'Unknown error occurred: {{ error }}. Please manually convert the fixture API call to fetch API call.',
+        'Unknown error occurred in file "{{fileName}}": {{ error }}. Please manually convert the fixture API call to fetch API call.',
     },
     fixable: 'code',
     schema: [],
   },
+  // eslint-disable-next-line max-lines-per-function
   create(context) {
     const sourceCode = context.sourceCode;
     const scopeManager = sourceCode.scopeManager;
     const scopeVariablesMap = new Map<Scope.Scope, string[]>();
 
     return {
+      // eslint-disable-next-line max-lines-per-function
       'CallExpression[callee.object.object.name="fixture"][callee.object.property.name="api"]': (
         fixtureCall: CallExpression,
       ) => {
@@ -302,15 +344,16 @@ const rule: Rule.RuleModule = {
           assert.ok(urlArgumentNode !== undefined);
 
           const fixtureCallInformation = {} as FixtureCallInformation;
-          analyzeFixtureCall(fixtureCall, fixtureCallInformation);
+          analyzeFixtureCall(fixtureCall, fixtureCallInformation, sourceCode);
 
           const {
             variable: responseVariable,
             bodyReferences: responseBodyReferences,
             headersReferences: responseHeadersReferences,
             statusReferences: responseStatusReferences,
-            spreadBodyVariable: spreadResponseBodyVariable,
-            spreadHeadersVariable: spreadResponseHeadersVariable,
+            destructuringBodyVariable: destructuringResponseBodyVariable,
+            destructuringHeadersVariable: destructuringResponseHeadersVariable,
+            // destructuringHeadersReferences: destructuringResponseHeadersReferences,
           } = analyzeResponseReferences(fixtureCallInformation, scopeManager);
 
           // convert url from `/sample-service/v1/ping` to `${BASE_PATH}/ping`
@@ -346,17 +389,30 @@ const rule: Rule.RuleModule = {
             scopeVariablesMap,
           );
 
-          const needResponseVariableRedefine =
-            spreadResponseBodyVariable !== undefined ||
-            (responseVariable === undefined && fixtureCallInformation.assertions !== undefined);
+          const isResponseBodyVariableRedefinitionNeeded =
+            destructuringResponseBodyVariable !== undefined ||
+            fixtureCallInformation.inlineBodyReference !== undefined ||
+            (responseBodyReferences.length > 0 && !responseBodyReferences.some(isResponseBodyRedefinition));
+          const redefineResponseBodyVariableName = `${responseVariableNameToUse}Body`;
+
+          const isResponseVariableRedefinitionNeeded =
+            (responseVariable === undefined && fixtureCallInformation.assertions !== undefined) ||
+            isResponseBodyVariableRedefinitionNeeded;
 
-          const responseBodyHeadersVariableRedefineLines = needResponseVariableRedefine
+          const responseBodyHeadersVariableRedefineLines = isResponseVariableRedefinitionNeeded
             ? [
-                ...(spreadResponseBodyVariable
-                  ? [`const ${spreadResponseBodyVariable.name} = await ${responseVariableNameToUse}.json()`]
-                  : []),
-                ...(spreadResponseHeadersVariable
-                  ? [`const ${spreadResponseHeadersVariable.name} = ${responseVariableNameToUse}.headers`]
+                // eslint-disable-next-line no-nested-ternary
+                ...(destructuringResponseBodyVariable
+                  ? [
+                      `const ${destructuringResponseBodyVariable.name} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`,
+                    ]
+                  : isResponseBodyVariableRedefinitionNeeded
+                    ? [
+                        `const ${redefineResponseBodyVariableName} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`,
+                      ]
+                    : []),
+                ...(destructuringResponseHeadersVariable
+                  ? [`const ${destructuringResponseHeadersVariable.name} = ${responseVariableNameToUse}.headers`]
                   : []),
               ]
             : [];
@@ -365,15 +421,16 @@ const rule: Rule.RuleModule = {
             fixtureCallInformation,
             sourceCode,
             responseVariableNameToUse,
+            destructuringResponseHeadersVariable,
           );
 
           // add variable declaration if needed
           const fetchCallText = `fetch(${fetchUrlArgumentText}, ${fetchRequestArgumentLines})`;
-          const fetchStatementText = !needResponseVariableRedefine
+          const fetchStatementText = !isResponseVariableRedefinitionNeeded
             ? fetchCallText
             : `const ${responseVariableNameToUse} = await ${fetchCallText}`;
 
-          const nodeToReplace = needResponseVariableRedefine
+          const nodeToReplace = isResponseVariableRedefinitionNeeded
             ? fixtureCallInformation.rootNode
             : fixtureCallInformation.fixtureNode;
           const appendingAssignmentAndAssertionText = [
@@ -386,18 +443,35 @@ const rule: Rule.RuleModule = {
           context.report({
             node: fixtureCall,
             messageId: 'preferNativeFetch',
+            // eslint-disable-next-line sonarjs/cognitive-complexity
             *fix(fixer) {
-              yield fixer.replaceText(nodeToReplace, fetchStatementText);
-
-              const needEndingSemiColon = sourceCode.getText(nodeToReplace).endsWith(';');
-              yield fixer.insertTextAfter(
-                nodeToReplace,
-                needEndingSemiColon ? `${appendingAssignmentAndAssertionText};` : appendingAssignmentAndAssertionText,
-              );
+              if (fixtureCallInformation.inlineStatementNode) {
+                const preInlineDeclaration = [
+                  fetchStatementText,
+                  `${appendingAssignmentAndAssertionText};\n${indentation}`,
+                ].join(``);
+                yield fixer.insertTextBefore(fixtureCallInformation.inlineStatementNode, preInlineDeclaration);
+              } else {
+                yield fixer.replaceText(nodeToReplace, fetchStatementText);
+
+                const needEndingSemiColon = sourceCode.getText(nodeToReplace).endsWith(';');
+                yield fixer.insertTextAfter(
+                  nodeToReplace,
+                  needEndingSemiColon ? `${appendingAssignmentAndAssertionText};` : appendingAssignmentAndAssertionText,
+                );
+              }
 
               // handle response body references
               for (const responseBodyReference of responseBodyReferences) {
-                yield fixer.replaceText(responseBodyReference, `await ${responseVariableNameToUse}.json()`);
+                yield fixer.replaceText(
+                  responseBodyReference,
+                  isResponseBodyVariableRedefinitionNeeded || !isResponseBodyRedefinition(responseBodyReference)
+                    ? redefineResponseBodyVariableName
+                    : getResponseBodyRetrievalText(responseVariableNameToUse),
+                );
+              }
+              if (fixtureCallInformation.inlineBodyReference) {
+                yield fixer.replaceText(fixtureCallInformation.inlineBodyReference, redefineResponseBodyVariableName);
               }
 
               // handle response headers references
@@ -414,9 +488,22 @@ const rule: Rule.RuleModule = {
                   const headerNameNode = parent.arguments[0];
                   headerName = sourceCode.getText(headerNameNode);
                 }
-                assert.ok(headerName);
+                assert.ok(headerName !== undefined);
                 yield fixer.replaceText(parent, `${responseVariableNameToUse}.headers.get(${headerName})`);
               }
+              // if (destructuringResponseHeadersVariable !== undefined) {
+              //   for (const destructuringResponseHeadersReference of destructuringResponseHeadersReferences ?? []) {
+              //     const headerNameNode = destructuringResponseHeadersReference.property;
+              //     const headerName = destructuringResponseHeadersReference.computed
+              //       ? sourceCode.getText(headerNameNode)
+              //       : `'${sourceCode.getText(headerNameNode)}'`;
+
+              //     yield fixer.replaceText(
+              //       destructuringResponseHeadersReference,
+              //       `${destructuringResponseHeadersVariable.name}.get(${headerName})`,
+              //     );
+              //   }
+              // }
 
               // convert response.statusCode to response.status
               for (const responseStatusReference of responseStatusReferences) {
@@ -428,7 +515,7 @@ const rule: Rule.RuleModule = {
                 }
               }
 
-              // handle direct return without await
+              // handle direct return statement without await, e.g. "return fixture.api.get(...);"
               if (
                 fixtureCallInformation.rootNode.type === 'ReturnStatement' &&
                 fixtureCallInformation.assertions !== undefined
@@ -441,12 +528,14 @@ const rule: Rule.RuleModule = {
             },
           });
         } catch (error) {
-          console.error(`Failed to apply ${ruleId} rule. Error:`, error);
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
           context.report({
             node: fixtureCall,
             messageId: 'unknownError',
             data: {
-              error: String(error),
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
             },
           });
         }