@testomatio/reporter 2.20.0 → 2.21.0

package/src/reporter-functions.js

@@ -1,8 +1,11 @@
+import { createRequire } from 'module';
 import { playwrightLogsMarkers } from './adapter/utils/playwright.js';
 import { isPlaywright } from './helpers.js';
 import { services } from './services/index.js';
 import pc from 'picocolors';
 
+const requireModule = createRequire(`${process.cwd()}/package.json`);
+
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
  * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
@@ -44,6 +47,36 @@ function addStep(message, logs) {
   else services.logger.step(message, logs);
 }
 
+/**
+ * Returns the currently running Vitest test task, so `meta()` (and similar
+ * functions) can attach data to it. The task `.meta` object is serialized by
+ * Vitest back to the reporter (works across all pools: threads, forks, vmThreads).
+ *
+ * Resolution order matters:
+ * 1. `globalThis.__vitest_worker__.current` — set by Vitest in every worker and
+ *    independent of module resolution, so it works even when the reporter is the
+ *    externalized package and `@vitest/runner` is deduped to a different instance
+ *    (monorepos, pnpm, hoisting). This is also populated inside hooks (afterEach),
+ *    pointing at the test that the hook belongs to.
+ * 2. `@vitest/runner` `getCurrentTest()` — fallback for setups/versions where the
+ *    worker global is not exposed.
+ *
+ * @returns {any | null} Vitest test task or null when no test is active
+ */
+function getCurrentVitestTest() {
+  // @ts-ignore - injected by Vitest into the worker global scope
+  const worker = globalThis.__vitest_worker__;
+  const current = worker?.current;
+  if (current && (current.type === 'test' || current.type === undefined)) return current;
+
+  try {
+    const test = requireModule('@vitest/runner').getCurrentTest?.();
+    if (test) return test;
+  } catch {}
+
+  return null;
+}
+
 /**
  * Add key-value pair(s) to the test report
  * @param {{[key: string]: string} | string} keyValue - object { key: value } (multiple props allowed) OR key (string)
@@ -67,6 +100,14 @@ function setKeyValue(keyValue, value = undefined) {
     return;
   }
 
+  if (process.env.VITEST || process.env.VITEST_WORKER_ID) {
+    const vitestTest = getCurrentVitestTest();
+    if (vitestTest) {
+      Object.assign((vitestTest.meta ||= {}), keyValue);
+      return;
+    }
+  }
+
   // in this case keyValue is expected to be an object
   services.keyValues.put(keyValue);
 }

package/src/uploader.js

@@ -347,6 +347,33 @@ export class S3Uploader {
     );
   }
 
+  /**
+   * Download an artifact by its link: from the configured bucket through S3, otherwise over plain HTTP.
+   *
+   * @param {string} link
+   * @param {string} filePath
+   */
+  async downloadFile(link, filePath) {
+    const { S3_BUCKET } = this.getConfig();
+    const Key = getS3KeyFromUrl(link, S3_BUCKET);
+    let body;
+
+    if (Key) {
+      debug('Downloading from S3:', Key);
+      const s3 = new S3(this.#getS3Config());
+      const object = await s3.getObject({ Bucket: S3_BUCKET, Key });
+      body = Buffer.from(await object.Body.transformToByteArray());
+    } else {
+      debug('Downloading over HTTP:', link);
+      const response = await fetch(link);
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+      body = Buffer.from(await response.arrayBuffer());
+    }
+
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, body);
+  }
+
   async getS3LocationLink(out) {
     const response = await out.done();
 
@@ -409,3 +436,27 @@ export class S3Uploader {
     return cfg;
   }
 }
+
+/**
+ * Object key of an artifact link in the given bucket, for both virtual-hosted (bucket.host/key)
+ * and path style (host/bucket/key) links; null when the link points to another bucket.
+ *
+ * @param {string} link
+ * @param {string} [bucket]
+ * @returns {string|null}
+ */
+export function getS3KeyFromUrl(link, bucket) {
+  if (!bucket) return null;
+
+  let url;
+  try {
+    url = new URL(link);
+  } catch (e) {
+    return null;
+  }
+
+  const objectPath = decodeURIComponent(url.pathname.slice(1));
+  if (url.hostname.startsWith(`${bucket}.`)) return objectPath || null;
+  if (objectPath.startsWith(`${bucket}/`)) return objectPath.slice(bucket.length + 1) || null;
+  return null;
+}

package/src/utils/detectRunner.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import path from 'path';
+import pc from 'picocolors';
+
+const LAUNCHER_PREFIXES = ['npx', 'npm', 'yarn', 'pnpm', 'bun', 'node', 'bunx'];
+
+const PLACEHOLDER_PHRASE_RE = /^<?-*(?:run|your|test)\s+(?:[\w-]+\s+)?(?:tests?|command|runner)>?$/i;
+
+const RUNNERS = [
+  {
+    name: 'Playwright',
+    configs: ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs', 'playwright.config.cjs'],
+    dependencies: ['@playwright/test'],
+    command: 'npx playwright test',
+  },
+  {
+    name: 'CodeceptJS',
+    configs: ['codecept.conf.js', 'codecept.conf.ts'],
+    dependencies: ['codeceptjs'],
+    command: 'npx codeceptjs run',
+  },
+  {
+    name: 'WebdriverIO',
+    configs: ['wdio.conf.js', 'wdio.conf.ts'],
+    dependencies: ['@wdio/cli'],
+    dependencyPrefix: '@wdio/',
+    command: 'npx wdio run ./wdio.conf.js',
+  },
+  {
+    name: 'Cypress',
+    configs: ['cypress.config.js', 'cypress.config.ts'],
+    dependencies: ['cypress'],
+    command: 'npx cypress run',
+  },
+  {
+    name: 'Jest',
+    configs: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs', 'jest.config.json'],
+    dependencies: ['jest'],
+    command: 'npx jest',
+  },
+  {
+    name: 'Vitest',
+    configs: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'],
+    dependencies: ['vitest'],
+    command: 'npx vitest run',
+  },
+  {
+    name: 'Mocha',
+    configs: ['.mocharc.js', '.mocharc.cjs', '.mocharc.json', '.mocharc.yml', '.mocharc.yaml'],
+    dependencies: ['mocha'],
+    command: 'npx mocha',
+  },
+  {
+    name: 'Cucumber',
+    configs: ['cucumber.js', 'cucumber.cjs'],
+    dependencies: ['@cucumber/cucumber'],
+    command: 'npx cucumber-js',
+  },
+];
+
+/**
+ * @param {string} command
+ * @returns {boolean}
+ */
+function isPlaceholderCommand(command) {
+  const cmd = (command || '').trim();
+  if (!cmd) return false;
+
+  if (cmd.includes('<') || cmd.includes('>')) return true;
+
+  const firstToken = cmd.split(/\s+/)[0].toLowerCase();
+  if (LAUNCHER_PREFIXES.includes(firstToken)) return false;
+
+  return PLACEHOLDER_PHRASE_RE.test(cmd);
+}
+
+/**
+ * @param {string} cwd
+ * @returns {Record<string, string>}
+ */
+function readPackageDependencies(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    return { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {{ name: string, command: string } | null}
+ */
+function detectRunner(cwd = process.cwd()) {
+  const dependencies = readPackageDependencies(cwd);
+
+  for (const runner of RUNNERS) {
+    const config = runner.configs.find(file => fs.existsSync(path.join(cwd, file)));
+
+    const hasDependency = runner.dependencies?.some(dep => dependencies[dep])
+      || (runner.dependencyPrefix && Object.keys(dependencies).some(dep => dep.startsWith(runner.dependencyPrefix)));
+
+    if (!config && !hasDependency) continue;
+
+    let command = runner.command;
+    if (runner.name === 'WebdriverIO') {
+      command = `npx wdio run ./${config || 'wdio.conf.js'}`;
+    }
+
+    return { name: runner.name, command };
+  }
+
+  return null;
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+function runnerHint(cwd = process.cwd()) {
+  const runner = detectRunner(cwd);
+  if (runner) {
+    return `💡 Looks like this project uses ${runner.name}. Try: ${pc.green(runner.command)}`;
+  }
+  return `💡 Replace the placeholder with your test runner command, e.g. ${pc.green('npx playwright test')}`;
+}
+
+/**
+ * @param {string} command
+ * @returns {string[]}
+ */
+function buildFilterWarning(command) {
+  return [
+    '⚠️  The runner exited with a non-zero code while a Testomat.io filter was applied.',
+    'Your command was modified to run only tests matching Testomat IDs:',
+    `  ${pc.bold(command)}`,
+    'This usually means no local tests matched the filter:',
+    '  - tests are not annotated with the matching @Txxxxxx IDs in their titles',
+    '  - the filter selected tests from another repository or branch',
+    '  - the test runner does not support the appended --grep / --testNamePattern option',
+    '💡 Hint: run the printed command without the appended filter option to see all your tests,',
+    'then annotate them with Testomat IDs.',
+  ];
+}
+
+export {
+  isPlaceholderCommand,
+  detectRunner,
+  runnerHint,
+  buildFilterWarning,
+};