private async generateApiScenarioTestResult()

in lib/apiScenario/newmanReportValidator.ts [158:317]
140 lines of code
31 McCabe index (conditional complexity)

  private async generateApiScenarioTestResult(newmanReport: NewmanReport) {
    this.testResult.operationIds = this.swaggerAnalyzer.getOperations();
    this.testResult.startTime = new Date(newmanReport.timings.started).toISOString();
    this.testResult.endTime = new Date(newmanReport.timings.completed).toISOString();
    const visitedIds = new Set<string>();
    for (const it of newmanReport.executions) {
      if (!it.annotation) {
        continue;
      }
      if (visitedIds.has(it.id)) {
        continue;
      }
      visitedIds.add(it.id);

      if (it.annotation.type !== "simple" && it.annotation.type !== "LRO") {
        continue;
      }

      const payload = this.convertToLiveValidationPayload(it);
      let lroFinalPayLoad;

      // associate  final get response to the
      if (it.annotation.type === "LRO" && [200, 201, 202].includes(it.response.statusCode)) {
        const lroFinalGetExecution = this.getLROFinalResponse(
          newmanReport.executions,
          it.annotation.step
        );
        if (lroFinalGetExecution?.response.statusCode === 200) {
          lroFinalPayLoad = this.convertToLROLiveValidationPayload(it, lroFinalGetExecution);
        }
      }

      let payloadFilePath;
      let lroPayloadFilePath;
      if (this.opts.savePayload) {
        payloadFilePath = `./payloads/${it.annotation.itemName}.json`;
        await this.fileLoader.writeFile(
          path.resolve(path.dirname(this.opts.reportOutputFilePath), payloadFilePath),
          JSON.stringify(payload, null, 2)
        );
        if (lroFinalPayLoad) {
          lroPayloadFilePath = `./payloads/${it.annotation.itemName}-finalResult.json`;
          await this.fileLoader.writeFile(
            path.resolve(path.dirname(this.opts.reportOutputFilePath), lroPayloadFilePath),
            JSON.stringify(lroFinalPayLoad, null, 2)
          );
        }
      }

      const matchedStep = this.getMatchedStep(it.annotation.step);
      if (matchedStep === undefined) {
        continue;
      }

      const runtimeError: RuntimeError[] = [];

      it.assertions.forEach((assertion) => {
        if (assertion.message.includes("expected response code to be 2XX")) {
          const error = this.getRuntimeError(it);
          runtimeError.push(error);
          return;
        }

        runtimeError.push({
          code: "ASSERTION_ERROR",
          message: `${assertion.message}`,
          severity: "Error",
          detail: this.dataMasker.jsonStringify(assertion.stack),
        });
      });

      let liveValidationResult = undefined;
      let roundtripValidationResult = undefined;
      let liveValidationForLroFinalGetResult = undefined;
      let specFilePath = undefined;
      if (matchedStep.type === "restCall" && !matchedStep.externalReference) {
        if (this.opts.generateExample) {
          const statusCode = `${it.response.statusCode}`;
          let statusCodes = {
            [statusCode]: {
              headers: payload.liveResponse.headers,
              body: payload.liveResponse.body,
            },
          };
          if (lroFinalPayLoad) {
            const statusCode = lroFinalPayLoad.liveResponse.statusCode;
            statusCodes[statusCode] = {
              headers: lroFinalPayLoad.liveResponse.headers,
              body: lroFinalPayLoad.liveResponse.body,
            };
          }

          const generatedExample: SwaggerExample = {
            operationId: matchedStep.operationId,
            title: matchedStep.step,
            description: matchedStep.description,
            parameters: matchedStep._resolvedParameters!,
            responses: {
              ...statusCodes,
            },
          };

          const exampleFilePath = `./examples/${matchedStep.operationId}_${Object.keys(
            statusCodes
          ).join("_")}.json`;
          await this.fileLoader.writeFile(
            path.resolve(path.dirname(this.opts.reportOutputFilePath), exampleFilePath),
            JSON.stringify(generatedExample, null, 2)
          );
        }

        // Schema validation
        liveValidationResult = !this.opts.skipValidation
          ? await this.liveValidator.validateLiveRequestResponse(payload)
          : undefined;

        liveValidationForLroFinalGetResult =
          !this.opts.skipValidation && lroFinalPayLoad && matchedStep.isManagementPlane
            ? await this.liveValidator.validateLiveRequestResponse(lroFinalPayLoad)
            : undefined;

        // Roundtrip validation
        if (
          !this.opts.skipValidation &&
          matchedStep.isManagementPlane &&
          matchedStep.operation?._method === "put" &&
          it.response.statusCode >= 200 &&
          it.response.statusCode <= 202
        ) {
          if (it.annotation.type === "LRO") {
            // For LRO, get the final response to compose payload
            const lroFinal = this.getLROFinalResponse(newmanReport.executions, it.annotation.step);
            if (lroFinal !== undefined && lroFinal.response.statusCode === 200) {
              const lroPayload = this.convertToLROLiveValidationPayload(it, lroFinal);
              roundtripValidationResult = await this.liveValidator.validateRoundTrip(lroPayload);
            }
          } else if (it.annotation.type === "simple") {
            roundtripValidationResult = await this.liveValidator.validateRoundTrip(payload);
          }
        }

        specFilePath = matchedStep.operation?._path._spec._filePath;
      }

      this.testResult.stepResult.push({
        specFilePath,
        operationId: it.annotation.operationId,
        payloadPath: payloadFilePath
          ? path.join(path.basename(path.dirname(this.opts.reportOutputFilePath)), payloadFilePath)
          : undefined,
        runtimeError,
        responseTime: it.response.responseTime,
        statusCode: it.response.statusCode,
        stepName: it.annotation.step,
        liveValidationResult,
        roundtripValidationResult,
        liveValidationForLroFinalGetResult,
      });
    }
  }