@flakiness/report 0.92.0 → 0.95.0

package/lib/junit.js

@@ -1,196 +0,0 @@
-import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
-import assert from "assert";
-import fs from "fs";
-import path from "path";
-import { FlakinessReport as FK } from "./common/flakinessReport.js";
-import { sha1Buffer, sha1File } from "./utils.js";
-function getProperties(element) {
-  const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
-  if (!propertiesNodes.length)
-    return [];
-  const result = [];
-  for (const propertiesNode of propertiesNodes) {
-    const properties = propertiesNode.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "property");
-    for (const property of properties) {
-      const name = property.attributes["name"];
-      const innerText = property.children.find((node) => node instanceof XmlText);
-      const value = property.attributes["value"] ?? innerText?.text ?? "";
-      result.push([name, value]);
-    }
-  }
-  return result;
-}
-function extractErrors(testcase) {
-  const xmlErrors = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === "error" || element.name === "failure");
-  if (!xmlErrors.length)
-    return void 0;
-  const errors = [];
-  for (const xmlErr of xmlErrors) {
-    const message = [xmlErr.attributes["type"], xmlErr.attributes["message"]].filter((x) => !!x).join(" ");
-    const xmlStackNodes = xmlErr.children.filter((child) => child instanceof XmlText);
-    const stack = xmlStackNodes ? xmlStackNodes.map((node) => node.text).join("\n") : void 0;
-    errors.push({
-      message,
-      stack
-    });
-  }
-  return errors;
-}
-function extractStdout(testcase, stdio) {
-  const xmlStdio = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === stdio);
-  if (!xmlStdio.length)
-    return void 0;
-  return xmlStdio.map((node) => node.children.filter((node2) => node2 instanceof XmlText)).flat().map((txtNode) => ({
-    text: txtNode.text
-  }));
-}
-async function parseAttachment(value) {
-  let absolutePath = path.resolve(process.cwd(), value);
-  if (fs.existsSync(absolutePath)) {
-    const id = await sha1File(absolutePath);
-    return {
-      contentType: "image/png",
-      path: absolutePath,
-      id
-    };
-  }
-  return {
-    contentType: "text/plain",
-    id: sha1Buffer(value),
-    body: Buffer.from(value)
-  };
-}
-async function traverseJUnitReport(context, node) {
-  const element = node;
-  if (!(element instanceof XmlElement))
-    return;
-  let { currentEnv, currentEnvIndex, currentSuite, report, currentTimeMs, attachments } = context;
-  if (element.attributes["timestamp"])
-    currentTimeMs = new Date(element.attributes["timestamp"]).getTime();
-  if (element.name === "testsuite") {
-    const file = element.attributes["file"];
-    const line = parseInt(element.attributes["line"], 10);
-    const name = element.attributes["name"];
-    const newSuite = {
-      title: name ?? file,
-      location: file && !isNaN(line) ? {
-        file,
-        line,
-        column: 1
-      } : FK.NO_LOCATION,
-      type: name ? "suite" : file ? "file" : "anonymous suite",
-      suites: [],
-      tests: []
-    };
-    if (currentSuite) {
-      currentSuite.suites ??= [];
-      currentSuite.suites.push(newSuite);
-    } else {
-      report.suites.push(newSuite);
-    }
-    currentSuite = newSuite;
-    const userSuppliedData = getProperties(element);
-    if (userSuppliedData.length) {
-      currentEnv = structuredClone(currentEnv);
-      currentEnv.userSuppliedData ??= {};
-      for (const [key, value] of userSuppliedData)
-        currentEnv.userSuppliedData[key] = value;
-      currentEnvIndex = report.environments.push(currentEnv) - 1;
-    }
-  } else if (element.name === "testcase") {
-    assert(currentSuite);
-    const file = element.attributes["file"];
-    const name = element.attributes["name"];
-    const line = parseInt(element.attributes["line"], 10);
-    const timeMs = parseFloat(element.attributes["time"]) * 1e3;
-    const startTimestamp = currentTimeMs;
-    const duration = timeMs;
-    currentTimeMs += timeMs;
-    const annotations = [];
-    const attachments2 = [];
-    for (const [key, value] of getProperties(element)) {
-      if (key.toLowerCase().startsWith("attachment")) {
-        if (context.ignoreAttachments)
-          continue;
-        const attachment = await parseAttachment(value);
-        context.attachments.set(attachment.id, attachment);
-        attachments2.push({
-          id: attachment.id,
-          contentType: attachment.contentType,
-          //TODO: better default names for attachments?
-          name: attachment.path ? path.basename(attachment.path) : `attachment`
-        });
-      } else {
-        annotations.push({
-          type: key,
-          description: value.length ? value : void 0
-        });
-      }
-    }
-    const childElements = element.children.filter((child) => child instanceof XmlElement);
-    const xmlSkippedAnnotation = childElements.find((child) => child.name === "skipped");
-    if (xmlSkippedAnnotation)
-      annotations.push({ type: "skipped", description: xmlSkippedAnnotation.attributes["message"] });
-    const expectedStatus = xmlSkippedAnnotation ? "skipped" : "passed";
-    const errors = extractErrors(element);
-    const test = {
-      title: name,
-      location: file && !isNaN(line) ? {
-        file,
-        line,
-        column: 1
-      } : FK.NO_LOCATION,
-      attempts: [{
-        environmentIdx: currentEnvIndex,
-        expectedStatus,
-        annotations,
-        attachments: attachments2,
-        startTimestamp,
-        duration,
-        status: xmlSkippedAnnotation ? "skipped" : errors ? "failed" : "passed",
-        errors,
-        stdout: extractStdout(element, "system-out"),
-        stderr: extractStdout(element, "system-err")
-      }]
-    };
-    currentSuite.tests ??= [];
-    currentSuite.tests.push(test);
-  }
-  context = { ...context, currentEnv, currentEnvIndex, currentSuite, currentTimeMs };
-  for (const child of element.children)
-    await traverseJUnitReport(context, child);
-}
-async function parseJUnit(xmls, options) {
-  const report = {
-    category: "junit",
-    commitId: options.commitId,
-    duration: options.runDuration,
-    startTimestamp: options.runStartTimestamp,
-    url: options.runUrl,
-    environments: [options.defaultEnv],
-    suites: [],
-    unattributedErrors: []
-  };
-  const context = {
-    currentEnv: options.defaultEnv,
-    currentEnvIndex: 0,
-    currentTimeMs: 0,
-    report,
-    currentSuite: void 0,
-    attachments: /* @__PURE__ */ new Map(),
-    ignoreAttachments: !!options.ignoreAttachments
-  };
-  for (const xml of xmls) {
-    const doc = parseXml(xml);
-    for (const element of doc.children)
-      await traverseJUnitReport(context, element);
-  }
-  return {
-    report: FK.dedupeSuitesTestsEnvironments(report),
-    attachments: Array.from(context.attachments.values())
-  };
-}
-export {
-  parseJUnit
-};
-//# sourceMappingURL=junit.js.map

package/lib/playwright-test.js

@@ -1,235 +0,0 @@
-import { Multimap } from "@flakiness/shared/common/multimap.js";
-import fs from "fs";
-import path from "path";
-import { FlakinessReport as FK } from "./common/flakinessReport.js";
-import { createTestStepSnippets } from "./createTestStepSnippets.js";
-import { ReportUploader } from "./reportUploader.js";
-import { SystemUtilizationSampler } from "./systemUtilizationSampler.js";
-import { computeGitRoot, createEnvironments, existsAsync, gitCommitInfo, gitFilePath, inferRunUrl, normalizePath, parseDurationMS, sha1Buffer, sha1File, stripAnsi } from "./utils.js";
-class FlakinessReporter {
-  constructor(_options = {}) {
-    this._options = _options;
-  }
-  _config;
-  _rootSuite;
-  _results = new Multimap();
-  _unattributedErrors = [];
-  _filepathToSteps = new Multimap();
-  _systemUtilizationSampler = new SystemUtilizationSampler();
-  printsToStdio() {
-    return false;
-  }
-  onBegin(config, suite) {
-    this._config = config;
-    this._rootSuite = suite;
-  }
-  onError(error) {
-    this._unattributedErrors.push(error);
-  }
-  onTestBegin(test) {
-  }
-  onTestEnd(test, result) {
-    this._results.set(test, result);
-  }
-  async _toFKSuites(context, pwSuite) {
-    const location = pwSuite.location;
-    if (pwSuite.type === "root" || pwSuite.type === "project" || !location)
-      return (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat();
-    let type = "suite";
-    if (pwSuite.type === "file")
-      type = "file";
-    else if (pwSuite.type === "describe" && !pwSuite.title)
-      type = "anonymous suite";
-    return [{
-      type,
-      title: pwSuite.title,
-      location: this._createLocation(context, location),
-      suites: (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat(),
-      tests: await Promise.all(pwSuite.tests.map((test) => this._toFKTest(context, test)))
-    }];
-  }
-  async _toFKTest(context, pwTest) {
-    return {
-      title: pwTest.title,
-      // Playwright Test tags must start with '@' so we cut it off.
-      tags: pwTest.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
-      location: this._createLocation(context, pwTest.location),
-      // de-duplication of tests will happen later, so here we will have all attempts.
-      attempts: await Promise.all(this._results.getAll(pwTest).map((result) => this._toFKRunAttempt(context, pwTest, result)))
-    };
-  }
-  async _toFKRunAttempt(context, pwTest, result) {
-    const attachments = [];
-    const attempt = {
-      timeout: parseDurationMS(pwTest.timeout),
-      annotations: pwTest.annotations.map((annotation) => ({
-        type: annotation.type,
-        description: annotation.description,
-        location: annotation.location ? this._createLocation(context, annotation.location) : void 0
-      })),
-      environmentIdx: context.project2environmentIdx.get(pwTest.parent.project()),
-      expectedStatus: pwTest.expectedStatus,
-      parallelIndex: result.parallelIndex,
-      status: result.status,
-      errors: result.errors && result.errors.length ? result.errors.map((error) => this._toFKTestError(context, error)) : void 0,
-      stdout: result.stdout ? result.stdout.map(toSTDIOEntry) : void 0,
-      stderr: result.stderr ? result.stderr.map(toSTDIOEntry) : void 0,
-      steps: result.steps ? result.steps.map((jsonTestStep) => this._toFKTestStep(context, jsonTestStep)) : void 0,
-      startTimestamp: +result.startTime,
-      duration: +result.duration,
-      attachments
-    };
-    await Promise.all((result.attachments ?? []).map(async (jsonAttachment) => {
-      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
-        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
-        return;
-      }
-      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
-      context.attachments.set(id, {
-        contentType: jsonAttachment.contentType,
-        id,
-        body: jsonAttachment.body,
-        path: jsonAttachment.path
-      });
-      attachments.push({
-        id,
-        name: jsonAttachment.name,
-        contentType: jsonAttachment.contentType
-      });
-    }));
-    return attempt;
-  }
-  _toFKTestStep(context, pwStep) {
-    const step = {
-      // NOTE: jsonStep.duration was -1 in some playwright versions
-      duration: parseDurationMS(Math.max(pwStep.duration, 0)),
-      title: pwStep.title,
-      location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
-    };
-    if (pwStep.location) {
-      const resolvedPath = path.resolve(pwStep.location.file);
-      this._filepathToSteps.set(resolvedPath, step);
-    }
-    if (pwStep.error)
-      step.error = this._toFKTestError(context, pwStep.error);
-    if (pwStep.steps)
-      step.steps = pwStep.steps.map((childJSONStep) => this._toFKTestStep(context, childJSONStep));
-    return step;
-  }
-  _createLocation(context, pwLocation) {
-    return {
-      file: gitFilePath(context.gitRoot, normalizePath(pwLocation.file)),
-      line: pwLocation.line,
-      column: pwLocation.column
-    };
-  }
-  _toFKTestError(context, pwError) {
-    return {
-      location: pwError.location ? this._createLocation(context, pwError.location) : void 0,
-      message: stripAnsi(pwError.message ?? "").split("\n")[0],
-      snippet: pwError.snippet,
-      stack: pwError.stack,
-      value: pwError.value
-    };
-  }
-  async onEnd(result) {
-    this._systemUtilizationSampler.dispose();
-    if (!this._config || !this._rootSuite)
-      throw new Error("ERROR: failed to resolve config");
-    const uploadOptions = ReportUploader.optionsFromEnv({
-      flakinessAccessToken: this._options.token,
-      flakinessEndpoint: this._options.endpoint
-    });
-    if (!uploadOptions) {
-      console.log(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
-      return;
-    }
-    let commitId;
-    try {
-      commitId = gitCommitInfo(this._config.rootDir);
-    } catch (e) {
-      console.log(`[flakiness.io] Uploading skipped since failed to get commit info - is this a git repo?`);
-      return;
-    }
-    const gitRoot = normalizePath(computeGitRoot(this._config.rootDir));
-    const configPath = this._config.configFile ? gitFilePath(gitRoot, normalizePath(this._config.configFile)) : void 0;
-    const context = {
-      project2environmentIdx: /* @__PURE__ */ new Map(),
-      testBaseDir: normalizePath(this._config.rootDir),
-      gitRoot,
-      attachments: /* @__PURE__ */ new Map(),
-      unaccessibleAttachmentPaths: []
-    };
-    const environmentsMap = createEnvironments(this._config.projects);
-    if (this._options.collectBrowserVersions) {
-      try {
-        let playwrightPath = fs.realpathSync(process.argv[1]);
-        while (path.basename(playwrightPath) !== "test")
-          playwrightPath = path.dirname(playwrightPath);
-        const module = await import(path.join(playwrightPath, "index.js"));
-        for (const [project, env] of environmentsMap) {
-          const { browserName = "chromium", channel, headless } = project.use;
-          let browserType;
-          switch (browserName) {
-            case "chromium":
-              browserType = module.default.chromium;
-              break;
-            case "firefox":
-              browserType = module.default.firefox;
-              break;
-            case "webkit":
-              browserType = module.default.webkit;
-              break;
-            default:
-              throw new Error(`Unsupported browser: ${browserName}`);
-          }
-          const browser = await browserType.launch({ channel, headless });
-          const version = browser.version();
-          await browser.close();
-          env.userSuppliedData ??= {};
-          env.userSuppliedData["browser"] = (channel ?? browserName).toLowerCase().trim() + " " + version;
-        }
-      } catch (e) {
-        console.error("[flakiness.io] failed to resolve browser version", e);
-      }
-    }
-    const environments = [...environmentsMap.values()];
-    for (let envIdx = 0; envIdx < environments.length; ++envIdx)
-      context.project2environmentIdx.set(this._config.projects[envIdx], envIdx);
-    const relatedCommitIds = this._options.relatedCommitIds;
-    const report = FK.dedupeSuitesTestsEnvironments({
-      category: "playwright",
-      commitId,
-      relatedCommitIds,
-      systemUtilization: this._systemUtilizationSampler.result,
-      configPath,
-      url: inferRunUrl(),
-      environments,
-      suites: await this._toFKSuites(context, this._rootSuite),
-      opaqueData: this._config,
-      unattributedErrors: this._unattributedErrors.map((e) => this._toFKTestError(context, e)),
-      duration: parseDurationMS(result.duration),
-      startTimestamp: +result.startTime
-    });
-    createTestStepSnippets(this._filepathToSteps);
-    for (const unaccessibleAttachment of context.unaccessibleAttachmentPaths)
-      console.warn(`[flakiness.io] WARN: cannot access attachment ${unaccessibleAttachment}`);
-    const uploadError = await ReportUploader.upload({
-      report,
-      attachments: [...context.attachments.values()],
-      ...uploadOptions,
-      log: console.log
-    });
-    if (uploadError)
-      return { status: "failed" };
-  }
-}
-function toSTDIOEntry(data) {
-  if (Buffer.isBuffer(data))
-    return { buffer: data.toString("base64") };
-  return { text: data };
-}
-export {
-  FlakinessReporter as default
-};
-//# sourceMappingURL=playwright-test.js.map

package/lib/playwrightJSONReport.js

@@ -1,178 +0,0 @@
-import debug from "debug";
-import { posix as posixPath } from "path";
-import { FlakinessReport as FK, FlakinessReport } from "./common/flakinessReport.js";
-import { computeGitRoot, createEnvironments, existsAsync, getOSInfo, gitCommitInfo, gitFilePath, inferRunUrl, normalizePath, parseDurationMS, parseStringDate, sha1Buffer, sha1File, stripAnsi } from "./utils.js";
-const dlog = debug("flakiness:json-report");
-var PlaywrightJSONReport;
-((PlaywrightJSONReport2) => {
-  function collectMetadata(somePathInsideProject = process.cwd()) {
-    const commitId = gitCommitInfo(somePathInsideProject);
-    const osInfo = getOSInfo();
-    const metadata = {
-      gitRoot: computeGitRoot(somePathInsideProject),
-      commitId,
-      osName: osInfo.name,
-      arch: osInfo.arch,
-      osVersion: osInfo.version,
-      runURL: inferRunUrl()
-    };
-    dlog(`metadata directory: ${somePathInsideProject}`);
-    dlog(`metadata: ${JSON.stringify(metadata)}`);
-    dlog(`commit info: ${JSON.stringify(commitId)}`);
-    dlog(`os info: ${JSON.stringify(osInfo)}`);
-    return metadata;
-  }
-  PlaywrightJSONReport2.collectMetadata = collectMetadata;
-  async function parse(metadata, jsonReport, options) {
-    const context = {
-      projectId2environmentIdx: /* @__PURE__ */ new Map(),
-      testBaseDir: normalizePath(jsonReport.config.rootDir),
-      gitRoot: metadata.gitRoot,
-      attachments: /* @__PURE__ */ new Map(),
-      unaccessibleAttachmentPaths: [],
-      extractAttachments: options.extractAttachments
-    };
-    const configPath = jsonReport.config.configFile ? gitFilePath(context.gitRoot, normalizePath(jsonReport.config.configFile)) : void 0;
-    const report = {
-      category: FlakinessReport.CATEGORY_PLAYWRIGHT,
-      commitId: metadata.commitId,
-      configPath,
-      url: metadata.runURL,
-      environments: [],
-      suites: [],
-      opaqueData: jsonReport.config,
-      unattributedErrors: jsonReport.errors.map((error) => parseJSONError(context, error)),
-      // The report.stats is a releatively new addition to Playwright's JSONReport,
-      // so we have to polyfill with some reasonable values when it's missing.
-      duration: jsonReport.stats?.duration && jsonReport.stats?.duration > 0 ? parseDurationMS(jsonReport.stats.duration) : 0,
-      startTimestamp: jsonReport.stats && jsonReport.stats.startTime ? parseStringDate(jsonReport.stats.startTime) : Date.now()
-    };
-    report.environments = [...createEnvironments(jsonReport.config.projects).values()];
-    for (let envIdx = 0; envIdx < report.environments.length; ++envIdx)
-      context.projectId2environmentIdx.set(jsonReport.config.projects[envIdx].id, envIdx);
-    report.suites = await Promise.all(jsonReport.suites.map((suite) => parseJSONSuite(context, suite)));
-    return {
-      report: FK.dedupeSuitesTestsEnvironments(report),
-      attachments: [...context.attachments.values()],
-      unaccessibleAttachmentPaths: context.unaccessibleAttachmentPaths
-    };
-  }
-  PlaywrightJSONReport2.parse = parse;
-})(PlaywrightJSONReport || (PlaywrightJSONReport = {}));
-async function parseJSONSuite(context, jsonSuite) {
-  let type = "suite";
-  if (jsonSuite.column === 0 && jsonSuite.line === 0)
-    type = "file";
-  else if (!jsonSuite.title)
-    type = "anonymous suite";
-  const suite = {
-    type,
-    title: jsonSuite.title,
-    location: {
-      file: gitFilePath(context.gitRoot, normalizePath(jsonSuite.file)),
-      line: jsonSuite.line,
-      column: jsonSuite.column
-    }
-  };
-  if (jsonSuite.suites && jsonSuite.suites.length)
-    suite.suites = await Promise.all(jsonSuite.suites.map((suite2) => parseJSONSuite(context, suite2)));
-  if (jsonSuite.specs && jsonSuite.specs.length)
-    suite.tests = await Promise.all(jsonSuite.specs.map((spec) => parseJSONSpec(context, spec)));
-  return suite;
-}
-async function parseJSONSpec(context, jsonSpec) {
-  const test = {
-    title: jsonSpec.title,
-    tags: jsonSpec.tags,
-    location: {
-      file: gitFilePath(context.gitRoot, normalizePath(posixPath.join(context.testBaseDir, normalizePath(jsonSpec.file)))),
-      line: jsonSpec.line,
-      column: jsonSpec.column
-    },
-    attempts: []
-  };
-  for (const jsonTest of jsonSpec.tests) {
-    const environmentIdx = context.projectId2environmentIdx.get(jsonTest.projectId);
-    if (environmentIdx === void 0)
-      throw new Error("Inconsistent report - no project for a test found!");
-    const testResults = jsonTest.results.filter((result) => result.status !== void 0);
-    if (!testResults.length)
-      continue;
-    test.attempts.push(...await Promise.all(testResults.map((jsonTestResult) => parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult))));
-  }
-  return test;
-}
-function createLocation(context, location) {
-  return {
-    file: gitFilePath(context.gitRoot, normalizePath(location.file)),
-    line: location.line,
-    column: location.column
-  };
-}
-async function parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult) {
-  const attachments = [];
-  const attempt = {
-    timeout: parseDurationMS(jsonTest.timeout),
-    annotations: jsonTest.annotations.map((annotation) => ({
-      type: annotation.type,
-      description: annotation.description,
-      location: annotation.location ? createLocation(context, annotation.location) : void 0
-    })),
-    environmentIdx,
-    expectedStatus: jsonTest.expectedStatus,
-    parallelIndex: jsonTestResult.parallelIndex,
-    status: jsonTestResult.status,
-    errors: jsonTestResult.errors && jsonTestResult.errors.length ? jsonTestResult.errors.map((error) => parseJSONError(context, error)) : void 0,
-    stdout: jsonTestResult.stdout && jsonTestResult.stdout.length ? jsonTestResult.stdout : void 0,
-    stderr: jsonTestResult.stderr && jsonTestResult.stderr.length ? jsonTestResult.stderr : void 0,
-    steps: jsonTestResult.steps ? jsonTestResult.steps.map((jsonTestStep) => parseJSONTestStep(context, jsonTestStep)) : void 0,
-    startTimestamp: parseStringDate(jsonTestResult.startTime),
-    duration: jsonTestResult.duration && jsonTestResult.duration > 0 ? parseDurationMS(jsonTestResult.duration) : 0,
-    attachments
-  };
-  if (context.extractAttachments) {
-    await Promise.all((jsonTestResult.attachments ?? []).map(async (jsonAttachment) => {
-      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
-        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
-        return;
-      }
-      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
-      context.attachments.set(id, {
-        contentType: jsonAttachment.contentType,
-        id,
-        body: jsonAttachment.body ? Buffer.from(jsonAttachment.body) : void 0,
-        path: jsonAttachment.path
-      });
-      attachments.push({
-        id,
-        name: jsonAttachment.name,
-        contentType: jsonAttachment.contentType
-      });
-    }));
-  }
-  return attempt;
-}
-function parseJSONTestStep(context, jsonStep) {
-  const step = {
-    // NOTE: jsonStep.duration was -1 in some playwright versions
-    duration: parseDurationMS(Math.max(jsonStep.duration, 0)),
-    title: jsonStep.title
-  };
-  if (jsonStep.error)
-    step.error = parseJSONError(context, jsonStep.error);
-  if (jsonStep.steps)
-    step.steps = jsonStep.steps.map((childJSONStep) => parseJSONTestStep(context, childJSONStep));
-  return step;
-}
-function parseJSONError(context, error) {
-  return {
-    location: error.location ? createLocation(context, error.location) : void 0,
-    message: error.message ? stripAnsi(error.message).split("\n")[0] : void 0,
-    stack: error.stack,
-    value: error.value
-  };
-}
-export {
-  PlaywrightJSONReport
-};
-//# sourceMappingURL=playwrightJSONReport.js.map