flakiness 0.0.0 → 0.147.0

package/lib/cli/cmd-whoami.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+// src/flakinessSession.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+import http from "http";
+import https from "https";
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
+    const request = protocol.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/serverapi.ts
+function createServerAPI(endpoint, options) {
+  endpoint += "/api/";
+  const fetcher = options?.auth ? (url, init) => fetch(url, {
+    ...init,
+    headers: {
+      ...init.headers,
+      "Authorization": `Bearer ${options.auth}`
+    }
+  }) : fetch;
+  if (options?.retries)
+    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
+  return TypedHTTP.createClient(endpoint, fetcher);
+}
+
+// src/flakinessSession.ts
+var CONFIG_DIR = (() => {
+  const configDir = process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "flakiness") : path.join(os.homedir(), ".config", "flakiness");
+  return configDir;
+})();
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var FlakinessSession = class _FlakinessSession {
+  constructor(_config) {
+    this._config = _config;
+    this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
+  }
+  static async loadOrDie() {
+    const session = await _FlakinessSession.load();
+    if (!session)
+      throw new Error(`Please login first with 'npx flakiness login'`);
+    return session;
+  }
+  static async load() {
+    const data = await fs.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
+    if (!data)
+      return void 0;
+    const json = JSON.parse(data);
+    return new _FlakinessSession(json);
+  }
+  static async remove() {
+    await fs.unlink(CONFIG_PATH).catch((e) => void 0);
+  }
+  api;
+  endpoint() {
+    return this._config.endpoint;
+  }
+  path() {
+    return CONFIG_PATH;
+  }
+  sessionToken() {
+    return this._config.token;
+  }
+  async save() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+  }
+};
+
+// src/cli/cmd-whoami.ts
+async function cmdWhoami() {
+  const session = await FlakinessSession.load();
+  if (!session) {
+    console.log('Not logged in. Run "flakiness login" first.');
+    process.exit(1);
+  }
+  console.log(`Logged into ${session.endpoint()}`);
+  const user = await session.api.user.whoami.GET();
+  console.log(user);
+}
+export {
+  cmdWhoami
+};
+//# sourceMappingURL=cmd-whoami.js.map

package/lib/flakinessSession.js

@@ -0,0 +1,159 @@
+// src/flakinessSession.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+import http from "http";
+import https from "https";
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
+    const request = protocol.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/serverapi.ts
+function createServerAPI(endpoint, options) {
+  endpoint += "/api/";
+  const fetcher = options?.auth ? (url, init) => fetch(url, {
+    ...init,
+    headers: {
+      ...init.headers,
+      "Authorization": `Bearer ${options.auth}`
+    }
+  }) : fetch;
+  if (options?.retries)
+    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
+  return TypedHTTP.createClient(endpoint, fetcher);
+}
+
+// src/flakinessSession.ts
+var CONFIG_DIR = (() => {
+  const configDir = process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "flakiness") : path.join(os.homedir(), ".config", "flakiness");
+  return configDir;
+})();
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var FlakinessSession = class _FlakinessSession {
+  constructor(_config) {
+    this._config = _config;
+    this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
+  }
+  static async loadOrDie() {
+    const session = await _FlakinessSession.load();
+    if (!session)
+      throw new Error(`Please login first with 'npx flakiness login'`);
+    return session;
+  }
+  static async load() {
+    const data = await fs.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
+    if (!data)
+      return void 0;
+    const json = JSON.parse(data);
+    return new _FlakinessSession(json);
+  }
+  static async remove() {
+    await fs.unlink(CONFIG_PATH).catch((e) => void 0);
+  }
+  api;
+  endpoint() {
+    return this._config.endpoint;
+  }
+  path() {
+    return CONFIG_PATH;
+  }
+  sessionToken() {
+    return this._config.token;
+  }
+  async save() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+  }
+};
+export {
+  FlakinessSession
+};
+//# sourceMappingURL=flakinessSession.js.map

package/lib/junit.js

@@ -0,0 +1,310 @@
+// src/junit.ts
+import { ReportUtils as ReportUtils2 } from "@flakiness/sdk";
+import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
+import assert from "assert";
+import fs2 from "fs";
+import path from "path";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+import crypto from "crypto";
+import fs from "fs";
+import http from "http";
+import https from "https";
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+    stream.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+function sha1Buffer(data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
+    const request = protocol.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/junit.ts
+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 (fs2.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
+      } : void 0,
+      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
+      } : void 0,
+      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: ReportUtils2.normalizeReport(report),
+    attachments: Array.from(context.attachments.values())
+  };
+}
+export {
+  parseJUnit
+};
+//# sourceMappingURL=junit.js.map