@bigbinary/neeto-playwright-reporter 2.2.0 → 3.0.0-beta.1

package/bin/neetoplaydash.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import { spawn } from "child_process";
+import * as R from "ramda";
+import smartOrchestrationApi from "./smartOrchestration.js";
+
+const pickTest = R.pick(["id", "title"]);
+
+const collectSpecs = suite =>
+  R.concat(
+    R.map(pickTest, suite.specs || []),
+    R.chain(collectSpecs, suite.suites || [])
+  );
+
+const extractTestTitlesAndIds = R.pipe(R.prop("suites"), R.chain(collectSpecs));
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] !== "playwright") {
+  console.error(`Usage: neetoplaydash playwright [options] <playwright commands and args>
+
+Required Options (via flags or environment variables):
+  --projectKey <key>    Project key for API calls (or NEETO_PROJECT_KEY env var)
+  --apiKey <key>        API key for authentication (or NEETO_API_KEY env var)
+  --ciBuildId <id>      CI build ID for tracking (or NEETO_CI_BUILD_ID env var)
+`);
+  process.exit(1);
+}
+
+const extractNeetoOption = (args, optionName) => {
+  const index = args.findIndex(
+    arg => arg === `--${optionName}` || arg.startsWith(`--${optionName}=`)
+  );
+  if (index === -1) return { value: null, filteredArgs: args };
+
+  const arg = args[index];
+  let value;
+  let argsToRemove = [index];
+
+  if (arg === `--${optionName}` && index + 1 < args.length) {
+    value = args[index + 1];
+    argsToRemove.push(index + 1);
+  } else if (arg.startsWith(`--${optionName}=`)) {
+    value = arg.substring(`--${optionName}=`.length);
+  }
+
+  const filteredArgs = args.filter((_, i) => !argsToRemove.includes(i));
+  return { value, filteredArgs };
+};
+
+let remainingArgs = args.slice(1);
+const neetoOptions = {};
+
+["projectKey", "apiKey", "ciBuildId"].forEach(option => {
+  const { value, filteredArgs } = extractNeetoOption(remainingArgs, option);
+  if (value) neetoOptions[option] = value;
+  remainingArgs = filteredArgs;
+});
+
+const projectKey = neetoOptions.projectKey || process.env.NEETO_PROJECT_KEY;
+const apiKey = neetoOptions.apiKey || process.env.NEETO_API_KEY;
+const ciBuildId = neetoOptions.ciBuildId || process.env.NEETO_CI_BUILD_ID;
+
+const missingOptions = [];
+if (!projectKey) missingOptions.push("--projectKey or NEETO_PROJECT_KEY");
+if (!apiKey) missingOptions.push("--apiKey or NEETO_API_KEY");
+if (!ciBuildId) missingOptions.push("--ciBuildId or NEETO_CI_BUILD_ID");
+
+if (missingOptions.length > 0) {
+  console.error(
+    `Error: Missing required options: ${missingOptions.join(", ")}`
+  );
+  console.error(
+    `\nUsage: neetoplaydash playwright --projectKey <key> --apiKey <key> --ciBuildId <id> <playwright commands and args>`
+  );
+  console.error(
+    `Or set environment variables: NEETO_PROJECT_KEY, NEETO_API_KEY, NEETO_CI_BUILD_ID`
+  );
+  process.exit(1);
+}
+
+const playwrightArgs = remainingArgs;
+
+const escapeShellArg = arg => {
+  if (arg.includes(" ") || arg.includes('"') || arg.includes("'")) {
+    return `"${arg.replace(/"/g, '\\"')}"`;
+  }
+  return arg;
+};
+
+const escapeRegexSpecialChars = str =>
+  str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const extractShardInfo = args => {
+  let currentShard = null;
+  let totalShards = null;
+
+  const shardIndex = args.findIndex(arg => arg.startsWith("--shard"));
+
+  if (shardIndex !== -1) {
+    const arg = args[shardIndex];
+    let shardValue;
+
+    if (arg === "--shard" && shardIndex + 1 < args.length) {
+      shardValue = args[shardIndex + 1];
+    } else if (arg.startsWith("--shard=")) {
+      shardValue = arg.substring("--shard=".length);
+    }
+
+    if (shardValue) {
+      const match = shardValue.match(/^(\d+)\/(\d+)$/);
+      if (match) {
+        currentShard = parseInt(match[1]);
+        totalShards = parseInt(match[2]);
+      }
+    }
+  }
+
+  return { currentShard, totalShards };
+};
+
+const filterArgs = (args, filterableArg) => {
+  return args.filter((arg, index) => {
+    if (arg === filterableArg || arg.startsWith(`${filterableArg}=`)) {
+      return false;
+    }
+    if (index > 0 && args[index - 1] === filterableArg) {
+      return false;
+    }
+    return true;
+  });
+};
+
+const filterShardArgs = args => filterArgs(args, "--shard");
+const filterGrepArgs = args => filterArgs(args, "--grep");
+
+const removeConsecutiveDuplicates = (args, value) => {
+  return args.filter((arg, index) => {
+    if (arg === value && index > 0 && args[index - 1] === value) {
+      return false;
+    }
+    return true;
+  });
+};
+
+const { currentShard, totalShards } = extractShardInfo(playwrightArgs);
+const filteredPlaywrightArgs = filterGrepArgs(filterShardArgs(playwrightArgs));
+
+const env = {
+  ...process.env,
+  DOTENV_CONFIG_QUIET: "true",
+  NODE_OPTIONS: "--no-warnings",
+};
+
+env.NEETO_PROJECT_KEY = projectKey;
+env.NEETO_API_KEY = apiKey;
+env.NEETO_CI_BUILD_ID = ciBuildId;
+
+if (currentShard !== null) {
+  env.NEETO_PLAYDASH_CURRENT_SHARD = currentShard.toString();
+}
+
+if (totalShards !== null) {
+  env.NEETO_PLAYDASH_TOTAL_SHARDS = totalShards.toString();
+}
+
+const finalArgs = [...playwrightArgs, "--reporter=json", "--list"];
+const escapedFinalArgs = finalArgs.map(escapeShellArg);
+const listCommand = `npx playwright ${escapedFinalArgs.join(" ")}`;
+
+const child = spawn(listCommand, {
+  env,
+  stdio: ["inherit", "pipe", "pipe"],
+  shell: true,
+});
+
+let stdout = "";
+
+child.stdout.on("data", data => {
+  stdout += data.toString();
+});
+
+child.on("close", async code => {
+  const output = stdout;
+
+  const firstBrace = output.indexOf("{");
+  const lastBrace = output.lastIndexOf("}");
+
+  if (firstBrace === -1 || lastBrace === -1 || firstBrace >= lastBrace) {
+    console.error("Command invalid. Please check the command and try again.");
+    process.exit(code || 1);
+  }
+
+  const jsonString = output.substring(firstBrace, lastBrace + 1);
+
+  try {
+    const json = JSON.parse(jsonString);
+    const tests = extractTestTitlesAndIds(json);
+    const historyIds = R.pluck("id", tests);
+
+    const smartOrchestrationPayload = {
+      total_shards: totalShards,
+      current_shard: currentShard,
+      ci_build_id: ciBuildId,
+      test_history_ids: historyIds,
+    };
+
+    const smartOrchestrationResponse = await smartOrchestrationApi.create({
+      payload: smartOrchestrationPayload,
+      apiKey,
+      projectKey,
+    });
+    const executableTests = smartOrchestrationResponse.data.tests;
+    const greppedTests = executableTests.map(escapeRegexSpecialChars).join("|");
+    const deduplicatedArgs = removeConsecutiveDuplicates(
+      filteredPlaywrightArgs,
+      "test"
+    );
+    const escapedArgs = deduplicatedArgs.map(escapeShellArg);
+    const command = `npx playwright ${escapedArgs.join(
+      " "
+    )} --reporter="@bigbinary/neeto-playwright-reporter" --grep="${greppedTests}"`;
+    const runChild = spawn(command, {
+      env,
+      stdio: "inherit",
+      shell: true,
+    });
+
+    runChild.on("close", exitCode => {
+      process.exit(exitCode || 0);
+    });
+
+    runChild.on("error", error => {
+      console.error(`Error executing test command: ${error.message}`);
+      process.exit(1);
+    });
+  } catch (error) {
+    console.error("Failed to parse JSON:", error.message);
+    process.exit(code || 1);
+  }
+});
+
+child.on("error", error => {
+  console.error(`Error executing command: ${error.message}`);
+  process.exit(1);
+});

package/bin/smartOrchestration.js

@@ -0,0 +1,24 @@
+import axios from "axios";
+
+const API_BASE_URL =
+  process.env.NEETO_PLAYDASH_API_BASE_URL ||
+  "https://connect.neetoplaydash.com";
+
+const create = ({ payload, apiKey, projectKey }) => {
+  return axios.post(
+    "/api/v2/reporter/smart_orchestration/distribute_tests",
+    { smart_orchestration: payload },
+    {
+      baseURL: API_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key": apiKey,
+        "Project-Key": projectKey,
+      },
+    }
+  );
+};
+
+const smartOrchestrationApi = { create };
+
+export default smartOrchestrationApi;