@checkdigit/eslint-plugin 6.6.0-PR.75-9891 → 6.6.0-PR.75-66d8

package/src/fixture/concurrent-promises.ts

@@ -6,12 +6,13 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import type { CallExpression, Expression, SimpleCallExpression } from 'estree';
-import { type Rule, SourceCode } from 'eslint';
+import type { CallExpression, Expression, MemberExpression, SimpleCallExpression } from 'estree';
+import { type Rule, type Scope, SourceCode } from 'eslint';
+import { getEnclosingStatement, getParent } from '../ast/tree';
 import { strict as assert } from 'node:assert';
 import getDocumentationUrl from '../get-documentation-url';
 import { getIndentation } from '../ast/format';
-import { getParent } from '../ast/tree';
+import { isInvalidResponseHeadersAccess } from './fetch';
 import { isValidPropertyName } from './variable';
 import { replaceEndpointUrlPrefixWithBasePath } from './url';
 
@@ -131,6 +132,54 @@ function createResponseAssertions(
   };
 }
 
+function getResponseHeadersAccesses(
+  responseVariables: Scope.Variable[],
+  scopeManager: Scope.ScopeManager,
+  sourceCode: SourceCode,
+) {
+  const responseHeadersAccesses: MemberExpression[] = [];
+  for (const responseVariable of responseVariables) {
+    for (const responseReference of responseVariable.references) {
+      const responseAccess = getParent(responseReference.identifier);
+      if (!responseAccess || responseAccess.type !== 'MemberExpression') {
+        continue;
+      }
+
+      const responseAccessParent = getParent(responseAccess);
+      if (!responseAccessParent) {
+        continue;
+      }
+
+      if (
+        responseAccessParent.type === 'CallExpression' &&
+        responseAccessParent.arguments[0]?.type === 'ArrowFunctionExpression'
+      ) {
+        // map-like operation against responses, e.g. responses.map((response) => response.headers.etag)
+        responseHeadersAccesses.push(
+          ...getResponseHeadersAccesses(
+            scopeManager.getDeclaredVariables(responseAccessParent.arguments[0]),
+            scopeManager,
+            sourceCode,
+          ),
+        );
+        continue;
+      }
+
+      if (
+        responseAccess.computed &&
+        responseAccess.property.type === 'Literal' &&
+        responseAccessParent.type === 'MemberExpression'
+      ) {
+        // header access through indexed responses array, e.g. responses[0].headers, responses[1].get(...), etc.
+        responseHeadersAccesses.push(responseAccessParent);
+      } else {
+        responseHeadersAccesses.push(responseAccess);
+      }
+    }
+  }
+  return responseHeadersAccesses;
+}
+
 const rule: Rule.RuleModule = {
   meta: {
     type: 'suggestion',
@@ -140,6 +189,7 @@ const rule: Rule.RuleModule = {
     },
     messages: {
       preferNativeFetch: 'Prefer native fetch API over customized fixture API.',
+      shouldUseHeaderGetter: 'Getter should be used to access response headers.',
       unknownError:
         'Unknown error occurred in file "{{fileName}}": {{ error }}. Please manually convert the fixture API call to fetch API call.',
     },
@@ -149,6 +199,7 @@ const rule: Rule.RuleModule = {
   // eslint-disable-next-line max-lines-per-function
   create(context) {
     const sourceCode = context.sourceCode;
+    const scopeManager = sourceCode.scopeManager;
 
     return {
       // eslint-disable-next-line max-lines-per-function
@@ -207,13 +258,15 @@ const rule: Rule.RuleModule = {
               ...(statusAssertion !== undefined ? [statusAssertion] : []),
               ...nonStatusAssertions,
             ].join(`;\n${indentation}`);
-            const replacementText = [
-              disableLintComment,
-              `${fetchCallText}.then((${responseVariableNameToUse}) => {`,
-              appendingAssignmentAndAssertionText === '' ? '' : `  ${appendingAssignmentAndAssertionText};`,
-              `  return ${responseVariableNameToUse};`,
-              `})`,
-            ].join(`\n${indentation}`);
+            const replacementText = fixtureCallInformation.assertions
+              ? [
+                  disableLintComment,
+                  `${fetchCallText}.then((${responseVariableNameToUse}) => {`,
+                  appendingAssignmentAndAssertionText === '' ? '' : `  ${appendingAssignmentAndAssertionText};`,
+                  `  return ${responseVariableNameToUse};`,
+                  `})`,
+                ].join(`\n${indentation}`)
+              : fetchCallText;
 
             context.report({
               node: fixtureCall,
@@ -222,6 +275,52 @@ const rule: Rule.RuleModule = {
                 return fixer.replaceText(fixtureCallInformation.fixtureNode, replacementText);
               },
             });
+
+            const responsesVariable = getEnclosingStatement(fixtureCallInformation.fixtureNode);
+            if (!responsesVariable) {
+              return;
+            }
+
+            const responseVariableReferences = scopeManager.getDeclaredVariables(responsesVariable);
+            const responseHeadersAccesses = getResponseHeadersAccesses(
+              responseVariableReferences,
+              scopeManager,
+              sourceCode,
+            );
+            for (const responseHeadersAccess of responseHeadersAccesses) {
+              if (isInvalidResponseHeadersAccess(responseHeadersAccess)) {
+                const headerAccess = getParent(responseHeadersAccess);
+                if (headerAccess?.type === 'MemberExpression') {
+                  const headerNameNode = headerAccess.property;
+                  const headerName = headerAccess.computed
+                    ? sourceCode.getText(headerNameNode)
+                    : `'${sourceCode.getText(headerNameNode)}'`;
+                  const headerAccessReplacementText = `${sourceCode.getText(headerAccess.object)}.get(${headerName})`;
+
+                  context.report({
+                    node: headerAccess,
+                    messageId: 'shouldUseHeaderGetter',
+                    fix(fixer) {
+                      return fixer.replaceText(headerAccess, headerAccessReplacementText);
+                    },
+                  });
+                } else if (
+                  headerAccess?.type === 'CallExpression' &&
+                  responseHeadersAccess.property.type === 'Identifier' &&
+                  responseHeadersAccess.property.name === 'get'
+                ) {
+                  const headerAccessReplacementText = `${sourceCode.getText(responseHeadersAccess.object)}.headers.get(${sourceCode.getText(headerAccess.arguments[0])})`;
+
+                  context.report({
+                    node: headerAccess,
+                    messageId: 'shouldUseHeaderGetter',
+                    fix(fixer) {
+                      return fixer.replaceText(headerAccess, headerAccessReplacementText);
+                    },
+                  });
+                }
+              }
+            }
           } catch (error) {
             // eslint-disable-next-line no-console
             console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);

package/src/fixture/fetch-header-getter.ts

@@ -6,12 +6,13 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import type { Identifier, MemberExpression, VariableDeclarator } from 'estree';
+import type { Identifier, VariableDeclarator } from 'estree';
 import type { Rule } from 'eslint';
 import { analyzeResponseReferences } from './response-reference';
 import { strict as assert } from 'node:assert';
 import getDocumentationUrl from '../get-documentation-url';
 import { getParent } from '../ast/tree';
+import { isInvalidResponseHeadersAccess } from './fetch';
 
 export const ruleId = 'fetch-header-getter';
 
@@ -42,12 +43,13 @@ const rule: Rule.RuleModule = {
         );
         assert.ok(responseVariable);
 
-        const directHeaderReferences = responseHeadersReferences
-          .map(getParent)
-          .filter((parent): parent is MemberExpression => parent?.type === 'MemberExpression');
+        const directHeadersReferences = responseHeadersReferences.filter((headersReference) => {
+          const headersAccess = getParent(headersReference);
+          return headersAccess?.type !== 'VariableDeclarator';
+        });
 
-        const indirectHeaderReferences = responseHeadersReferences
-          .map((reference) => getParent(reference))
+        const indirectHeadersReferences = responseHeadersReferences
+          .map(getParent)
           .filter((parent): parent is VariableDeclarator => parent?.type === 'VariableDeclarator')
           .map((declarator) => (declarator.id as Identifier).name)
           .map((redefinedHeadersVariableName) => {
@@ -55,32 +57,31 @@ const rule: Rule.RuleModule = {
               const identifier = variable.identifiers[0];
               return identifier?.type === 'Identifier' && identifier.name === redefinedHeadersVariableName;
             });
-            return (
-              headersVariable?.references
-                .map((reference) => getParent(reference.identifier))
-                .filter((parent): parent is MemberExpression => parent?.type === 'MemberExpression') ?? []
-            );
+            return headersVariable?.references.map((reference) => reference.identifier) ?? [];
           })
           .flat();
 
-        const invalidHeaderReferences = [...directHeaderReferences, ...indirectHeaderReferences].filter(
-          (reference) => !(reference.property.type === 'Identifier' && reference.property.name === 'get'),
+        const invalidHeadersReferences = [...directHeadersReferences, ...indirectHeadersReferences].filter(
+          isInvalidResponseHeadersAccess,
         );
 
-        invalidHeaderReferences.forEach((reference) => {
-          const headerNameNode = reference.property;
-          const headerName = reference.computed
-            ? sourceCode.getText(headerNameNode)
-            : `'${sourceCode.getText(headerNameNode)}'`;
-          const replacementText = `${sourceCode.getText(reference.object)}.get(${headerName})`;
+        invalidHeadersReferences.forEach((headersReference) => {
+          const headerAccess = getParent(headersReference);
+          if (headerAccess?.type === 'MemberExpression') {
+            const headerNameNode = headerAccess.property;
+            const headerName = headerAccess.computed
+              ? sourceCode.getText(headerNameNode)
+              : `'${sourceCode.getText(headerNameNode)}'`;
+            const replacementText = `${sourceCode.getText(headerAccess.object)}.get(${headerName})`;
 
-          context.report({
-            node: reference,
-            messageId: 'shouldUseHeaderGetter',
-            fix(fixer) {
-              return fixer.replaceText(reference, replacementText);
-            },
-          });
+            context.report({
+              node: headerAccess,
+              messageId: 'shouldUseHeaderGetter',
+              fix(fixer) {
+                return fixer.replaceText(headerAccess, replacementText);
+              },
+            });
+          }
         });
       },
     };

package/src/fixture/fetch.ts

@@ -1,5 +1,30 @@
 // fixture/fetch.ts
 
+import type { Node } from 'estree';
+import { getParent } from '../ast/tree';
+
 export function getResponseBodyRetrievalText(responseVariableName: string) {
   return `await ${responseVariableName}.json()`;
 }
+
+export function isInvalidResponseHeadersAccess(responseHeadersAccess: Node) {
+  const responseHeaderAccessParent = getParent(responseHeadersAccess);
+  if (responseHeaderAccessParent?.type === 'VariableDeclarator') {
+    return false;
+  }
+
+  if (
+    responseHeaderAccessParent?.type === 'CallExpression' &&
+    responseHeaderAccessParent.callee.type === 'MemberExpression' &&
+    responseHeaderAccessParent.callee.property.type === 'Identifier' &&
+    responseHeaderAccessParent.callee.property.name === 'get'
+  ) {
+    return true;
+  }
+
+  return !(
+    responseHeaderAccessParent?.type === 'MemberExpression' &&
+    responseHeaderAccessParent.property.type === 'Identifier' &&
+    responseHeaderAccessParent.property.name === 'get'
+  );
+}

package/src/fixture/no-fixture.ts

@@ -37,6 +37,7 @@ interface FixtureCallInformation {
   assertions?: Expression[][];
   inlineStatementNode?: Node;
   inlineBodyReference?: MemberExpression;
+  isConcurrent?: boolean;
 }
 
 // recursively analyze the fixture/supertest call chain to collect information of request/response
@@ -49,6 +50,8 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
     // direct return, no variable declaration or await
     results.fixtureNode = call;
     results.rootNode = parent;
+  } else if (parent.type === 'ArrayExpression') {
+    results.isConcurrent = true;
   } else if (parent.type === 'AwaitExpression') {
     results.fixtureNode = call;
     const enclosingStatement = getEnclosingStatement(parent);
@@ -245,6 +248,9 @@ const rule: Rule.RuleModule = {
 
           const fixtureCallInformation = {} as FixtureCallInformation;
           analyzeFixtureCall(fixtureCall, fixtureCallInformation, sourceCode);
+          if (fixtureCallInformation.isConcurrent === true) {
+            return;
+          }
 
           const {
             variable: responseVariable,

package/src/fixture/response-reference.ts

@@ -52,27 +52,19 @@ export function analyzeResponseReferences(
       // e.g. response.body
       results.bodyReferences = responseReferences.filter(
         (node): node is MemberExpression =>
-          node !== null &&
-          node !== undefined &&
-          node.type === 'MemberExpression' &&
-          node.property.type === 'Identifier' &&
-          node.property.name === 'body',
+          node?.type === 'MemberExpression' && node.property.type === 'Identifier' && node.property.name === 'body',
       );
       // e.g. response.headers / response.header / response.get()
       results.headersReferences = responseReferences.filter(
         (node): node is MemberExpression =>
-          node !== null &&
-          node !== undefined &&
-          node.type === 'MemberExpression' &&
+          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 = responseReferences.filter(
         (node): node is MemberExpression =>
-          node !== null &&
-          node !== undefined &&
-          node.type === 'MemberExpression' &&
+          node?.type === 'MemberExpression' &&
           node.property.type === 'Identifier' &&
           (node.property.name === 'status' || node.property.name === 'statusCode'),
       );