@checkdigit/eslint-plugin 7.6.0-PR.75-4751 → 7.6.0-PR.75-a611

package/dist-mjs/agent/fetch-response-body-json.mjs

@@ -14,7 +14,7 @@ var rule = createRule({
       description: 'Replace "response.body" with "await response.json()".'
     },
     messages: {
-      refactorNeeded: "Please extract the fetch call and check its reponse status code before accessing its response body.",
+      refactorNeeded: "Please extract the fetch call and check its response status code before accessing its response body.",
       replaceBodyWithJson: 'Replace "response.body" with "await response.json()".',
       unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
     },

package/dist-mjs/agent/fetch.mjs

@@ -35,7 +35,7 @@ function hasAssertions(fixtureCall) {
   return hasAssertions(parent);
 }
 function isFetchResponse(type) {
-  return type.getProperties().some((symbol) => symbol.name === "body") && type.getProperties().some((symbol) => symbol.name === "json");
+  return type.getProperties().some((symbol) => symbol.name === "json") && type.getProperties().some((symbol) => symbol.name === "status") && type.getProperties().some((symbol) => symbol.name === "headers") && type.getProperties().some((symbol) => symbol.name === "body");
 }
 export {
   getResponseBodyRetrievalText,
@@ -45,4 +45,4 @@ export {
   isFetchResponse,
   isInvalidResponseHeadersAccess
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2ZldGNoLnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQUVBLFNBQVMsc0JBQWdDO0FBQ3pDLE9BQWU7QUFFZixTQUFTLFdBQVcsd0JBQXdCO0FBRXJDLFNBQVMsNkJBQTZCLHNCQUE4QjtBQUN6RSxTQUFPLFNBQVMsb0JBQW9CO0FBQ3RDO0FBRU8sU0FBUywrQkFBK0Isc0JBQThCO0FBQzNFLFNBQU8sR0FBRyxvQkFBb0I7QUFDaEM7QUFFTyxTQUFTLGdDQUFnQyxzQkFBOEI7QUFDNUUsU0FBTyxHQUFHLG9CQUFvQjtBQUNoQztBQUVPLFNBQVMsK0JBQStCLHVCQUErQztBQUM1RixRQUFNLDZCQUE2QixVQUFVLHFCQUFxQjtBQUNsRSxNQUFJLDRCQUE0QixTQUFTLGVBQWUsb0JBQW9CO0FBQzFFLFdBQU87QUFBQSxFQUNUO0FBRUEsTUFDRSw0QkFBNEIsU0FBUyxlQUFlLGtCQUNwRCwyQkFBMkIsT0FBTyxTQUFTLGVBQWUsb0JBQzFELDJCQUEyQixPQUFPLFNBQVMsU0FBUyxlQUFlLGNBQ25FLDJCQUEyQixPQUFPLFNBQVMsU0FBUyxPQUNwRDtBQUNBLFdBQU87QUFBQSxFQUNUO0FBRUEsU0FBTyxFQUNMLDRCQUE0QixTQUFTLGVBQWUsb0JBQ3BELDJCQUEyQixTQUFTLFNBQVMsZUFBZSxjQUM1RCwyQkFBMkIsU0FBUyxTQUFTO0FBRWpEO0FBRU8sU0FBUyxjQUFjLGFBQXFDO0FBQ2pFLE1BQUksaUJBQWlCLFdBQVcsR0FBRztBQUNqQyxXQUFPO0FBQUEsRUFDVDtBQUVBLFFBQU0sU0FBUyxVQUFVLFdBQVc7QUFDcEMsTUFBSSxDQUFDLFFBQVE7QUFDWCxXQUFPO0FBQUEsRUFDVDtBQUVBLE1BQ0UsT0FBTyxTQUFTLGVBQWUsb0JBQy9CLE9BQU8sU0FBUyxTQUFTLGVBQWUsY0FDeEMsT0FBTyxTQUFTLFNBQVMsWUFDekIsVUFBVSxNQUFNLEdBQUcsU0FBUyxlQUFlLGdCQUMzQztBQUNBLFdBQU87QUFBQSxFQUNUO0FBRUEsU0FBTyxjQUFjLE1BQU07QUFDN0I7QUFFTyxTQUFTLGdCQUFnQixNQUF3QjtBQUN0RCxTQUNFLEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxNQUFNLEtBQzVELEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxNQUFNO0FBRWhFOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2ZldGNoLnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQUVBLFNBQVMsc0JBQWdDO0FBQ3pDLE9BQWU7QUFFZixTQUFTLFdBQVcsd0JBQXdCO0FBRXJDLFNBQVMsNkJBQTZCLHNCQUE4QjtBQUN6RSxTQUFPLFNBQVMsb0JBQW9CO0FBQ3RDO0FBRU8sU0FBUywrQkFBK0Isc0JBQThCO0FBQzNFLFNBQU8sR0FBRyxvQkFBb0I7QUFDaEM7QUFFTyxTQUFTLGdDQUFnQyxzQkFBOEI7QUFDNUUsU0FBTyxHQUFHLG9CQUFvQjtBQUNoQztBQUVPLFNBQVMsK0JBQStCLHVCQUErQztBQUM1RixRQUFNLDZCQUE2QixVQUFVLHFCQUFxQjtBQUNsRSxNQUFJLDRCQUE0QixTQUFTLGVBQWUsb0JBQW9CO0FBQzFFLFdBQU87QUFBQSxFQUNUO0FBRUEsTUFDRSw0QkFBNEIsU0FBUyxlQUFlLGtCQUNwRCwyQkFBMkIsT0FBTyxTQUFTLGVBQWUsb0JBQzFELDJCQUEyQixPQUFPLFNBQVMsU0FBUyxlQUFlLGNBQ25FLDJCQUEyQixPQUFPLFNBQVMsU0FBUyxPQUNwRDtBQUNBLFdBQU87QUFBQSxFQUNUO0FBRUEsU0FBTyxFQUNMLDRCQUE0QixTQUFTLGVBQWUsb0JBQ3BELDJCQUEyQixTQUFTLFNBQVMsZUFBZSxjQUM1RCwyQkFBMkIsU0FBUyxTQUFTO0FBRWpEO0FBRU8sU0FBUyxjQUFjLGFBQXFDO0FBQ2pFLE1BQUksaUJBQWlCLFdBQVcsR0FBRztBQUNqQyxXQUFPO0FBQUEsRUFDVDtBQUVBLFFBQU0sU0FBUyxVQUFVLFdBQVc7QUFDcEMsTUFBSSxDQUFDLFFBQVE7QUFDWCxXQUFPO0FBQUEsRUFDVDtBQUVBLE1BQ0UsT0FBTyxTQUFTLGVBQWUsb0JBQy9CLE9BQU8sU0FBUyxTQUFTLGVBQWUsY0FDeEMsT0FBTyxTQUFTLFNBQVMsWUFDekIsVUFBVSxNQUFNLEdBQUcsU0FBUyxlQUFlLGdCQUMzQztBQUNBLFdBQU87QUFBQSxFQUNUO0FBRUEsU0FBTyxjQUFjLE1BQU07QUFDN0I7QUFFTyxTQUFTLGdCQUFnQixNQUF3QjtBQUN0RCxTQUNFLEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxNQUFNLEtBQzVELEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxRQUFRLEtBQzlELEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxTQUFTLEtBQy9ELEtBQUssY0FBYyxFQUFFLEtBQUssQ0FBQyxXQUFXLE9BQU8sU0FBUyxNQUFNO0FBRWhFOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist-mjs/agent/no-expect-assertion.mjs

@@ -0,0 +1,394 @@
+// src/agent/no-expect-assertion.ts
+import { strict as assert } from "node:assert";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import "typescript";
+import {
+  getEnclosingFunction,
+  getEnclosingScopeNode,
+  getEnclosingStatement,
+  getParent,
+  isUsedInArrayOrAsArgument
+} from "../library/ts-tree.mjs";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { getIndentation } from "../library/format.mjs";
+import { analyzeResponseReferences } from "./response-reference.mjs";
+import {
+  getResponseBodyRetrievalText,
+  getResponseHeadersRetrievalText,
+  getResponseStatusRetrievalText,
+  isFetchResponse
+} from "./fetch.mjs";
+var ruleId = "no-expect-assertion";
+function analyzeFixtureCall(call, results, sourceCode) {
+  const parent = getParent(call);
+  assert.ok(parent, "parent should exist for fixture/supertest call node");
+  let nextCall;
+  if (parent.type === AST_NODE_TYPES.ReturnStatement) {
+    results.fixtureNode = call;
+    results.rootNode = parent;
+  } else if (parent.type === AST_NODE_TYPES.ArrayExpression || parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+    results.fixtureNode = call;
+    results.rootNode = call;
+  } else if (parent.type === AST_NODE_TYPES.AwaitExpression) {
+    results.fixtureNode = call;
+    const enclosingStatement = getEnclosingStatement(parent);
+    assert.ok(enclosingStatement);
+    const awaitParent = getParent(parent);
+    if (awaitParent?.type === AST_NODE_TYPES.MemberExpression) {
+      results.rootNode = parent;
+      results.inlineStatementNode = enclosingStatement;
+      if (awaitParent.property.type === AST_NODE_TYPES.Identifier && awaitParent.property.name === "body") {
+        results.inlineBodyReference = awaitParent;
+      }
+      if (awaitParent.property.type === AST_NODE_TYPES.Identifier && (awaitParent.property.name === "status" || awaitParent.property.name === "statusCode")) {
+        results.inlineStatusReference = awaitParent;
+      }
+      if (awaitParent.property.type === AST_NODE_TYPES.Identifier && (awaitParent.property.name === "header" || awaitParent.property.name === "headers")) {
+        results.inlineHeadersReference = awaitParent;
+      }
+    } else if (enclosingStatement.type === AST_NODE_TYPES.VariableDeclaration) {
+      results.variableDeclaration = enclosingStatement;
+      results.rootNode = enclosingStatement;
+    } else if (enclosingStatement.type === AST_NODE_TYPES.ExpressionStatement && enclosingStatement.expression.type === AST_NODE_TYPES.AssignmentExpression) {
+      results.variableAssignment = enclosingStatement;
+      results.rootNode = enclosingStatement;
+    } else {
+      results.rootNode = parent;
+    }
+  } else if (parent.type === AST_NODE_TYPES.MemberExpression && parent.property.type === AST_NODE_TYPES.Identifier) {
+    if (parent.property.name === "expect") {
+      const assertionCall = getParent(parent);
+      assert.ok(assertionCall && assertionCall.type === AST_NODE_TYPES.CallExpression);
+      results.assertions = [...results.assertions ?? [], assertionCall.arguments];
+      nextCall = assertionCall;
+    }
+  } else {
+    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}.`);
+  }
+  if (nextCall) {
+    analyzeFixtureCall(nextCall, results, sourceCode);
+  }
+}
+function createResponseAssertions(fixtureCallInformation, sourceCode, responseVariableName, destructuringResponseHeadersVariable) {
+  let statusAssertion;
+  const nonStatusAssertions = [];
+  for (const expectArguments of fixtureCallInformation.assertions ?? []) {
+    if (expectArguments.length === 1) {
+      const [assertionArgument] = expectArguments;
+      assert.ok(assertionArgument);
+      if (assertionArgument.type === AST_NODE_TYPES.MemberExpression && assertionArgument.object.type === AST_NODE_TYPES.Identifier && assertionArgument.object.name === "StatusCodes" || assertionArgument.type === AST_NODE_TYPES.Literal || sourceCode.getText(assertionArgument).includes("StatusCodes.")) {
+        statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
+      } else if (assertionArgument.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        let functionBody = sourceCode.getText(assertionArgument.body);
+        const [originalResponseArgument] = assertionArgument.params;
+        assert.ok(originalResponseArgument?.type === AST_NODE_TYPES.Identifier);
+        const originalResponseArgumentName = originalResponseArgument.name;
+        if (originalResponseArgumentName !== responseVariableName) {
+          functionBody = functionBody.replace(
+            new RegExp(`\\b${originalResponseArgumentName}\\b`, "ug"),
+            responseVariableName
+          );
+        }
+        nonStatusAssertions.push(`assert.doesNotThrow(()=>${functionBody})`);
+      } else if (assertionArgument.type === AST_NODE_TYPES.Identifier) {
+        nonStatusAssertions.push(
+          `assert.doesNotThrow(()=>${sourceCode.getText(assertionArgument)}(${responseVariableName}))`
+        );
+      } else if (assertionArgument.type === AST_NODE_TYPES.ObjectExpression || assertionArgument.type === AST_NODE_TYPES.CallExpression) {
+        nonStatusAssertions.push(
+          `assert.deepEqual(await ${responseVariableName}.json(), ${sourceCode.getText(assertionArgument)})`
+        );
+      } else {
+        throw new Error(`Unexpected Supertest assertion argument: ".expect(${sourceCode.getText(assertionArgument)})`);
+      }
+    } else if (expectArguments.length === 2) {
+      const [headerName, headerValue] = expectArguments;
+      assert.ok(headerName && headerValue);
+      const headersReference = destructuringResponseHeadersVariable !== void 0 ? destructuringResponseHeadersVariable.name : `${responseVariableName}.headers`;
+      if (headerValue.type === AST_NODE_TYPES.Literal && headerValue.value instanceof RegExp) {
+        nonStatusAssertions.push(
+          `assert.ok(${headersReference}.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`
+        );
+      } else {
+        nonStatusAssertions.push(
+          `assert.equal(${headersReference}.get(${sourceCode.getText(headerName)}), ${sourceCode.getText(headerValue)})`
+        );
+      }
+    }
+  }
+  return {
+    statusAssertion,
+    nonStatusAssertions
+  };
+}
+function getResponseVariableNameToUse(fetchFunction, fixtureCallInformation, sourceCode, scopeManager, scopeVariablesMap) {
+  if (fixtureCallInformation.variableAssignment) {
+    assert.ok(
+      fixtureCallInformation.variableAssignment.expression.type === AST_NODE_TYPES.AssignmentExpression && fixtureCallInformation.variableAssignment.expression.left.type === AST_NODE_TYPES.Identifier
+    );
+    return fixtureCallInformation.variableAssignment.expression.left.name;
+  }
+  if (fixtureCallInformation.variableDeclaration) {
+    const firstDeclaration = fixtureCallInformation.variableDeclaration.declarations[0];
+    if (firstDeclaration !== void 0 && firstDeclaration.id.type === AST_NODE_TYPES.Identifier) {
+      return firstDeclaration.id.name;
+    }
+  }
+  const enclosingScopeNode = getEnclosingScopeNode(fixtureCallInformation.rootNode);
+  assert.ok(enclosingScopeNode);
+  const scope = scopeManager.acquire(enclosingScopeNode);
+  assert.ok(scope);
+  let scopeVariables = scopeVariablesMap.get(scope);
+  if (!scopeVariables) {
+    scopeVariables = [...scope.set.keys()];
+    scopeVariablesMap.set(scope, scopeVariables);
+  }
+  let responseVariableNameBase;
+  if (fetchFunction.callee.type === AST_NODE_TYPES.Identifier && fetchFunction.callee.name === "fetch") {
+    const [urlArg, initArg] = fetchFunction.arguments;
+    if (urlArg?.type === AST_NODE_TYPES.Literal || urlArg?.type === AST_NODE_TYPES.TemplateLiteral) {
+      const urlValue = urlArg.type === AST_NODE_TYPES.Literal ? String(urlArg.value) : sourceCode.getText(urlArg);
+      const urlWithoutQuotes = urlValue.replace(/['"`]/gu, "");
+      const urlWithoutQuery = urlWithoutQuotes.includes("?") ? urlWithoutQuotes.slice(0, urlWithoutQuotes.indexOf("?")) : urlWithoutQuotes;
+      const parts = urlWithoutQuery.startsWith("${") ? urlWithoutQuery.split("/").slice(1) : (
+        // eslint-disable-next-line no-magic-numbers
+        urlWithoutQuery.split("/").slice(3)
+      );
+      let methodName;
+      if (initArg?.type === AST_NODE_TYPES.ObjectExpression) {
+        methodName = /method:\s*['"`](?<method>\w+)['"`]/u.exec(sourceCode.getText(initArg))?.groups?.["method"];
+      }
+      methodName ??= "GET";
+      responseVariableNameBase = [...parts.filter((part) => part !== "tenant"), methodName.toLowerCase()].map((part) => part.split(/[-]/u)).flat().filter((part) => part.trim() !== "" && !/\$\{.*\}/u.test(part)).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("");
+      responseVariableNameBase = `${responseVariableNameBase[0]?.toLowerCase() ?? ""}${responseVariableNameBase.slice(1)}`;
+    }
+  } else {
+    const fullUtilityFunctionReference = sourceCode.getText(fetchFunction.callee);
+    responseVariableNameBase = fullUtilityFunctionReference.split(".").pop();
+  }
+  responseVariableNameBase = responseVariableNameBase === void 0 ? "response" : `${responseVariableNameBase}Response`;
+  let responseVariableCounter = 0;
+  let responseVariableNameToUse = responseVariableNameBase;
+  while (scopeVariables.includes(responseVariableNameToUse)) {
+    responseVariableCounter++;
+    responseVariableNameToUse = `${responseVariableNameBase}${String(responseVariableCounter)}`;
+  }
+  scopeVariables.push(responseVariableNameToUse);
+  return responseVariableNameToUse;
+}
+function isResponseBodyRedefinition(responseBodyReference) {
+  const parent = getParent(responseBodyReference);
+  return parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier;
+}
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Transform supertest assersions to regular node assertions.",
+      url: getDocumentationUrl(ruleId)
+    },
+    messages: {
+      preferNativeFetch: "Transform supertest assersions to regular node assertions.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  // eslint-disable-next-line max-lines-per-function
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const parserServices = ESLintUtils.getParserServices(context);
+    const typeChecker = parserServices.program.getTypeChecker();
+    const scopeManager = sourceCode.scopeManager;
+    assert.ok(scopeManager !== null);
+    const scopeVariablesMap = /* @__PURE__ */ new Map();
+    return {
+      // eslint-disable-next-line max-lines-per-function
+      'CallExpression[callee.property.name="expect"]': (expectCall) => {
+        try {
+          if (expectCall.callee.type !== AST_NODE_TYPES.MemberExpression || expectCall.callee.object.type !== AST_NODE_TYPES.CallExpression) {
+            return;
+          }
+          const calleeObject = expectCall.callee.object;
+          const calleeObjectTsNode = parserServices.esTreeNodeToTSNodeMap.get(calleeObject);
+          const calleeObjectType = typeChecker.getTypeAtLocation(calleeObjectTsNode);
+          const calleeObjectTypeSymbol = calleeObjectType.getSymbol();
+          if (!calleeObjectTypeSymbol || calleeObjectTypeSymbol.name !== "Promise") {
+            return;
+          }
+          const [calleeObjectPromiseType] = typeChecker.getTypeArguments(calleeObjectType);
+          if (calleeObjectPromiseType === void 0 || !isFetchResponse(calleeObjectPromiseType)) {
+            return;
+          }
+          const indentation = getIndentation(expectCall, sourceCode);
+          const fixtureCallInformation = {};
+          const fetchFunction = expectCall.callee.object;
+          analyzeFixtureCall(fetchFunction, fixtureCallInformation, sourceCode);
+          const {
+            variable: responseVariable,
+            bodyReferences: responseBodyReferences,
+            // headersReferences: responseHeadersReferences,
+            statusReferences: responseStatusReferences,
+            destructuringBodyVariable: destructuringResponseBodyVariable,
+            destructuringHeadersVariable: destructuringResponseHeadersVariable,
+            destructuringStatusVariable: destructuringResponseStatusVariable
+          } = analyzeResponseReferences(fixtureCallInformation.variableDeclaration, scopeManager);
+          const shouldUsePromiseThen = isUsedInArrayOrAsArgument(expectCall) || getEnclosingFunction(expectCall)?.async === false;
+          if (shouldUsePromiseThen) {
+            const responseVariableNameToUse = "res";
+            const { statusAssertion, nonStatusAssertions } = createResponseAssertions(
+              fixtureCallInformation,
+              sourceCode,
+              responseVariableNameToUse,
+              destructuringResponseHeadersVariable
+            );
+            const fetchCallText = sourceCode.getText(fetchFunction);
+            const disableLintComment = "// eslint-disable-next-line @checkdigit/no-promise-instance-method";
+            const appendingAssignmentAndAssertionText = [
+              ...statusAssertion !== void 0 ? [statusAssertion] : [],
+              ...nonStatusAssertions
+            ].join(`;
+${indentation}`);
+            const replacementText = fixtureCallInformation.assertions ? [
+              disableLintComment,
+              `${fetchCallText}.then((${responseVariableNameToUse}) => {`,
+              appendingAssignmentAndAssertionText === "" ? "" : `  ${appendingAssignmentAndAssertionText};`,
+              `  return ${responseVariableNameToUse};`,
+              `})`
+            ].join(`
+${indentation}`) : fetchCallText;
+            context.report({
+              node: fixtureCallInformation.rootNode,
+              messageId: "preferNativeFetch",
+              fix(fixer) {
+                return fixer.replaceText(fixtureCallInformation.fixtureNode, replacementText);
+              }
+            });
+          } else {
+            const responseVariableNameToUse = getResponseVariableNameToUse(
+              fetchFunction,
+              fixtureCallInformation,
+              sourceCode,
+              scopeManager,
+              scopeVariablesMap
+            );
+            const isResponseBodyVariableRedefinitionNeeded = destructuringResponseBodyVariable !== void 0 || fixtureCallInformation.inlineBodyReference !== void 0 || responseBodyReferences.length > 0 && !responseBodyReferences.some(isResponseBodyRedefinition);
+            const redefineResponseBodyVariableName = `${responseVariableNameToUse}Body`;
+            const isResponseStatusVariableRedefinitionNeeded = destructuringResponseStatusVariable !== void 0 || fixtureCallInformation.inlineStatusReference !== void 0;
+            const redefineResponseStatusVariableName = `${responseVariableNameToUse}Status`;
+            const isResponseHeadersVariableRedefinitionNeeded = destructuringResponseHeadersVariable !== void 0 && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            destructuringResponseHeadersVariable.type === AST_NODE_TYPES.ObjectPattern || fixtureCallInformation.inlineHeadersReference !== void 0;
+            const redefineResponseHeadersVariableName = `${responseVariableNameToUse}Headers`;
+            const isResponseVariableRedefinitionNeeded = fixtureCallInformation.variableAssignment === void 0 && responseVariable === void 0 && fixtureCallInformation.assertions !== void 0 || isResponseBodyVariableRedefinitionNeeded || isResponseStatusVariableRedefinitionNeeded || isResponseHeadersVariableRedefinitionNeeded;
+            const responseBodyHeadersVariableRedefineLines = isResponseVariableRedefinitionNeeded ? [
+              // eslint-disable-next-line no-nested-ternary
+              ...destructuringResponseBodyVariable ? [
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${destructuringResponseBodyVariable.type === AST_NODE_TYPES.ObjectPattern ? sourceCode.getText(destructuringResponseBodyVariable) : destructuringResponseBodyVariable.name} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`
+              ] : isResponseBodyVariableRedefinitionNeeded ? [
+                `const ${redefineResponseBodyVariableName} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`
+              ] : [],
+              // eslint-disable-next-line no-nested-ternary
+              ...destructuringResponseStatusVariable ? [
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${destructuringResponseStatusVariable.type === AST_NODE_TYPES.ObjectPattern ? sourceCode.getText(destructuringResponseStatusVariable) : destructuringResponseStatusVariable.name} = ${getResponseStatusRetrievalText(responseVariableNameToUse)}`
+              ] : isResponseStatusVariableRedefinitionNeeded ? [
+                `const ${redefineResponseStatusVariableName} = ${getResponseStatusRetrievalText(responseVariableNameToUse)}`
+              ] : [],
+              // eslint-disable-next-line no-nested-ternary
+              ...destructuringResponseHeadersVariable ? (
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                destructuringResponseHeadersVariable.type === AST_NODE_TYPES.ObjectPattern ? destructuringResponseHeadersVariable.properties.map((property) => {
+                  assert.ok(property.type === AST_NODE_TYPES.Property);
+                  assert.ok(property.value.type === AST_NODE_TYPES.Identifier);
+                  return `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${property.value.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}.get(${property.key.type === AST_NODE_TYPES.Literal ? sourceCode.getText(property.key) : `'${sourceCode.getText(property.key)}'`})`;
+                }) : [
+                  `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${destructuringResponseHeadersVariable.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`
+                ]
+              ) : isResponseHeadersVariableRedefinitionNeeded ? [
+                `const ${redefineResponseHeadersVariableName} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`
+              ] : []
+            ] : [];
+            const { statusAssertion, nonStatusAssertions } = createResponseAssertions(
+              fixtureCallInformation,
+              sourceCode,
+              responseVariableNameToUse,
+              destructuringResponseHeadersVariable
+            );
+            const fetchCallText = sourceCode.getText(fetchFunction);
+            const fetchStatementText = !isResponseVariableRedefinitionNeeded ? fetchCallText : `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${responseVariableNameToUse} = await ${fetchCallText}`;
+            const nodeToReplace = isResponseVariableRedefinitionNeeded ? fixtureCallInformation.rootNode : fixtureCallInformation.fixtureNode;
+            const appendingAssignmentAndAssertionText = [
+              "",
+              ...statusAssertion !== void 0 ? [statusAssertion] : [],
+              ...responseBodyHeadersVariableRedefineLines,
+              ...nonStatusAssertions
+            ].join(`;
+${indentation}`);
+            context.report({
+              node: expectCall,
+              messageId: "preferNativeFetch",
+              *fix(fixer) {
+                if (fixtureCallInformation.inlineStatementNode) {
+                  const preInlineDeclaration = [
+                    fetchStatementText,
+                    `${appendingAssignmentAndAssertionText};
+${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
+                  );
+                }
+                for (const responseBodyReference of responseBodyReferences) {
+                  yield fixer.replaceText(
+                    responseBodyReference,
+                    isResponseBodyVariableRedefinitionNeeded || !isResponseBodyRedefinition(responseBodyReference) ? redefineResponseBodyVariableName : getResponseBodyRetrievalText(responseVariableNameToUse)
+                  );
+                }
+                if (fixtureCallInformation.inlineBodyReference) {
+                  yield fixer.replaceText(fixtureCallInformation.inlineBodyReference, redefineResponseBodyVariableName);
+                }
+                for (const responseStatusReference of responseStatusReferences) {
+                  if (responseStatusReference.property.type === AST_NODE_TYPES.Identifier && responseStatusReference.property.name === "statusCode") {
+                    yield fixer.replaceText(responseStatusReference.property, `status`);
+                  }
+                }
+                if (fixtureCallInformation.rootNode.type === AST_NODE_TYPES.ReturnStatement && fixtureCallInformation.assertions !== void 0) {
+                  yield fixer.insertTextAfter(
+                    fixtureCallInformation.rootNode,
+                    `
+${indentation}return ${responseVariableNameToUse};`
+                  );
+                }
+              }
+            });
+          }
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: expectCall,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var no_expect_assertion_default = rule;
+export {
+  no_expect_assertion_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/agent/no-expect-assertion.ts"],
  "mappings": "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",
  "names": []
}
