@testomatio/reporter 2.7.1 → 2.7.2

package/src/adapter/playwright.js

@@ -3,14 +3,16 @@ import os from 'os';
 import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import fs from 'fs';
-import { APP_PREFIX, STATUS as Status, TESTOMAT_TMP_STORAGE_DIR } from '../constants.js';
+import { APP_PREFIX, STATUS as Status, TESTOMAT_TMP_STORAGE_DIR, SCREENSHOTS_ON_STEPS } from '../constants.js';
 import TestomatioClient from '../client.js';
-import { getTestomatIdFromTestTitle, fileSystem } from '../utils/utils.js';
+import { getTestomatIdFromTestTitle, fileSystem, truncate } from '../utils/utils.js';
 import { services } from '../services/index.js';
 import { dataStorage } from '../data-storage.js';
 import { extensionMap } from '../utils/constants.js';
 import pc from 'picocolors';
 import { fetchLinksFromLogs } from './utils/playwright.js';
+import { formatStep, addStatusToStep, addArtifactsToStep } from './utils/step-formatter.js';
+import { log } from '../utils/log.js';
 
 const reportTestPromises = [];
 
@@ -35,7 +37,7 @@ class PlaywrightReporter {
     dataStorage.setContext(fullTestTitle);
   }
 
-  onTestEnd(test, result) {
+  async onTestEnd(test, result) {
     // test.parent.project().__projectId
 
     if (!this.client) return;
@@ -54,13 +56,26 @@ class PlaywrightReporter {
 
     const suite_title = test.parent ? test.parent?.title : path.basename(test?.location?.file);
 
-    const steps = [];
-    for (const step of result.steps) {
-      const appendedStep = appendStep(step);
-      if (appendedStep) {
-        steps.push(appendedStep);
-      }
-    }
+    const rid = test.id || test.testId || uuidv4();
+
+    /**
+     * @type {{
+     * browser?: string,
+     * dependencies: string[],
+     * isMobile?: boolean
+     * metadata: Record<string, any>,
+     * name: string,
+     * }}
+     */
+    const project = {
+      browser: test.parent.project().use.defaultBrowserType,
+      dependencies: test.parent.project().dependencies,
+      isMobile: test.parent.project().use.isMobile,
+      metadata: test.parent.project().metadata,
+      name: test.parent.project().name,
+    };
+
+    const steps = result.steps.map(step => appendStep(step, 0)).filter(step => step !== null);
 
     // Extract and normalize tags
     const tags = extractTags(test);
@@ -86,24 +101,6 @@ class PlaywrightReporter {
     */
     const manuallyAttachedArtifacts = services.artifacts.get(fullTestTitle);
     const testMeta = services.keyValues.get(fullTestTitle);
-    const rid = test.id || test.testId || uuidv4();
-
-    /**
-     * @type {{
-     * browser?: string,
-     * dependencies: string[],
-     * isMobile?: boolean
-     * metadata: Record<string, any>,
-     * name: string,
-     * }}
-     */
-    const project = {
-      browser: test.parent.project().use.defaultBrowserType,
-      dependencies: test.parent.project().dependencies,
-      isMobile: test.parent.project().use.isMobile,
-      metadata: test.parent.project().metadata,
-      name: test.parent.project().name,
-    };
 
     let status = result.status;
     // process test.fail() annotation
@@ -179,7 +176,7 @@ class PlaywrightReporter {
     await Promise.all(reportTestPromises);
 
     if (this.uploads.length) {
-      if (this.client.uploader.isEnabled) console.log(APP_PREFIX, `🎞️  Uploading ${this.uploads.length} files...`);
+      if (this.client.uploader.isEnabled) log.info(`🎞️ Uploading ${this.uploads.length} files...`);
 
       const promises = [];
 
@@ -242,6 +239,44 @@ function appendStep(step, shift = 0) {
       newCategory = 'framework';
   }
 
+  const resultStep = formatStep({
+    category: newCategory,
+    title: step.title,
+    duration: step.duration,
+  });
+
+  // Add status based on error
+  addStatusToStep(resultStep, step.error ? 'failed' : 'passed', step.error);
+
+  // Add error if present
+  if (step.error !== undefined) {
+    if (typeof step.error === 'object') {
+      resultStep.error = {
+        message: truncate(String(step.error.message), 250),
+        stack: truncate(String(step.error.stack || ''), 250),
+      };
+    } else {
+      resultStep.error = truncate(String(step.error), 250);
+    }
+  }
+
+  // Add log if present
+  if (step.log) {
+    resultStep.log = truncate(String(step.log), 250);
+  }
+
+  // Add artifacts from attachments
+  if (step.attachments && step.attachments.length > 0 && SCREENSHOTS_ON_STEPS) {
+    const screenshotAttachment = step.attachments.find(att =>
+      att.contentType === 'image/png' && att.name === 'screenshot'
+    );
+    if (screenshotAttachment && screenshotAttachment.path) {
+      const artifacts = { screenshot: screenshotAttachment.path };
+      addArtifactsToStep(resultStep, artifacts);
+    }
+  }
+
+  // Process nested steps
   const formattedSteps = [];
   for (const child of step.steps || []) {
     const appendedChild = appendStep(child, shift + 2);
@@ -250,20 +285,10 @@ function appendStep(step, shift = 0) {
     }
   }
 
-  const resultStep = {
-    category: newCategory,
-    title: step.title,
-    duration: step.duration,
-  };
-
   if (formattedSteps.length) {
     resultStep.steps = formattedSteps.filter(s => !!s);
   }
 
-  if (step.error !== undefined) {
-    resultStep.error = step.error;
-  }
-
   return resultStep;
 }
 

package/src/adapter/utils/step-formatter.js

@@ -0,0 +1,232 @@
+import { truncate } from '../../utils/utils.js';
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+
+/**
+ * Generates a short unique filename from screenshot path
+ * If original filename is too long, uses hash-based name
+ *
+ * @param {string} screenshotPath - Path to screenshot file
+ * @returns {string} Short filename (max 80 chars)
+ */
+export function generateShortFilename(screenshotPath) {
+  const originalFilename = path.basename(screenshotPath);
+  const stepPrefix = originalFilename.match(/^(\d{3,4}_)/)?.[1] || '';
+
+  if (originalFilename.length < 40) {
+    return originalFilename;
+  }
+
+  const ext = path.extname(screenshotPath);
+
+  const hash = crypto
+    .createHash('sha256')
+    .update(screenshotPath)
+    .digest('hex')
+    .slice(0, 16);
+
+  return `${stepPrefix}screenshot_${hash}${ext}`;
+}
+
+/**
+ * Formats a step object according to Testomat.io Step Schema
+ *
+ * This function transforms a raw step object from test frameworks (CodeceptJS, Playwright, etc.)
+ * into a standardized format compatible with Testomat.io API. It ensures all text fields are
+ * truncated to 250 characters as defined in testomat-api-definition.yml.
+ *
+ * Processed fields:
+ * - category: step type (framework, user, hook) - defaults to 'user'
+ * - title: step name/description, truncated to 250 chars
+ * - duration: step execution time in seconds
+ * - log: optional log output, truncated to 250 chars
+ * - artifacts: optional array of artifact URLs (screenshots), each truncated to 250 chars
+ * - error: error details (message + stack) if step failed, each truncated to 250 chars
+ * - steps: recursively formats nested steps
+ *
+ * Schema reference: testomat-api-definition.yml (Step object)
+ *
+ * @param {Object} step - Raw step object from test framework
+ * @param {string} [step.category] - Step category: 'user', 'framework', or 'hook'
+ * @param {string} [step.title] - Step title/name
+ * @param {number} [step.duration] - Step duration in seconds
+ * @param {string} [step.log] - Log output for this step
+ * @param {string[]} [step.artifacts] - Array of artifact URLs (screenshots)
+ * @param {string|Object} [step.error] - Error details - can be string or object with message/stack
+ * @param {Object[]} [step.steps] - Array of nested child steps
+ * @returns {Object} Formatted step object matching Testomat.io Step Schema with:
+ * category, title, duration, and optional log, artifacts, error, and steps fields
+ *
+ * @example
+ * const rawStep = {
+ *   category: 'user',
+ *   title: 'I click on button',
+ *   duration: 1.5,
+ *   error: { message: 'Element not found', stack: 'at test.js:10:5' }
+ * };
+ * const formatted = formatStep(rawStep);
+ * // Returns: { category: 'user', title: 'I click on button', duration: 1.5, error: {...} }
+ */
+export function formatStep(step) {
+  const formattedStep = {
+    category: step.category || 'user',
+    title: truncate(String(step.title || ''), 250),
+    duration: step.duration || 0,
+  };
+
+  if (step.log) {
+    formattedStep.log = truncate(String(step.log), 250);
+  }
+
+  if (step.artifacts && Array.isArray(step.artifacts)) {
+    formattedStep.artifacts = step.artifacts.map(artifact => truncate(String(artifact), 250));
+  }
+
+  if (step.error) {
+    if (typeof step.error === 'object') {
+      formattedStep.error = {
+        message: truncate(String(step.error.message || 'Step failed'), 250),
+        stack: truncate(String(step.error.stack || ''), 250),
+      };
+    } else {
+      formattedStep.error = truncate(String(step.error), 250);
+    }
+  }
+
+  if (step.steps && Array.isArray(step.steps)) {
+    formattedStep.steps = step.steps.map(s => formatStep(s));
+  }
+
+  return formattedStep;
+}
+
+/**
+ * Adds status field to step
+ *
+ * Normalizes step status from test frameworks to Testomat.io standard format.
+ * Maps framework-specific statuses ('success', 'failed', 'passed') to Testomat.io
+ * standard values ('passed', 'failed').
+ *
+ * Status mapping:
+ * - 'success' → 'passed'
+ * - 'passed' → 'passed'
+ * - 'failed' → 'failed'
+ * - Any other value → 'passed' (default)
+ *
+ * If step already has a status, it won't be overwritten. If error is provided
+ * and step doesn't have status, it will be set to 'failed'.
+ *
+ * Schema reference: testomat-api-definition.yml (Step.status enum)
+ *
+ * @param {Object} step - Step object to add status to (modified in place)
+ * @param {string} [step.status] - Existing status (won't be overwritten if present)
+ * @param {string} status - Status from test framework: 'success', 'failed', or 'passed'
+ * @param {Error|Object|null} err - Error object if step failed
+ * @returns {Object} The same step object with added status field
+ *
+ * @example
+ * const step = { title: 'Click button' };
+ * addStatusToStep(step, 'success', null);
+ * // step.status === 'passed'
+ *
+ * @example
+ * const step2 = { title: 'Find element' };
+ * addStatusToStep(step2, 'failed', new Error('Not found'));
+ * // step2.status === 'failed'
+ */
+export function addStatusToStep(step, status, err) {
+  if (step.status) return step;
+
+  const statusMap = {
+    'success': 'passed',
+    'failed': 'failed',
+    'passed': 'passed',
+  };
+
+  step.status = statusMap[status] || 'passed';
+
+  if (err && !step.status) {
+    step.status = 'failed';
+  }
+
+  return step;
+}
+
+/**
+ * Adds screenshot to step as artifacts array
+ *
+ * Extracts screenshot path from artifacts and adds it to the step's artifacts array.
+ * The actual upload will happen in the client's addTestRun method.
+ *
+ * Artifact format supports:
+ * - Array format: [{ screenshot: '/path/to/screenshot.png' }]
+ * - Object format: { screenshot: '/path/to/screenshot.png' }
+ *
+ * Screenshot path can be specified as:
+ * - Object with path property: { screenshot: { path: '/path/to/file.png' } }
+ * - Object with screenshot property: { screenshot: { screenshot: '/path/to/file.png' } }
+ * - Direct string path: { screenshot: '/path/to/file.png' }
+ *
+ * @param {Object} step - Step object to add artifacts to (modified in place)
+ * @param {string[]} [step.artifacts] - Existing artifacts array (won't be overwritten if present)
+ * @param {Object|Object[]|null} artifacts - Artifacts from test framework
+ * @returns {Object} The same step object with artifacts array added
+ *
+ * @example
+ * const step = { title: 'Click button' };
+ * const artifacts = { screenshot: '/tmp/screenshot.png' };
+ * addArtifactsToStep(step, artifacts);
+ * // step.artifacts === ['/tmp/screenshot.png']
+ */
+export function addArtifactsToStep(step, artifacts) {
+  if (!artifacts) return step;
+
+  let screenshotPath = null;
+
+  if (Array.isArray(artifacts)) {
+    const screenshotArtifact = artifacts.find(a => a.screenshot);
+    if (screenshotArtifact && screenshotArtifact.path) {
+      screenshotPath = screenshotArtifact.path;
+    } else if (screenshotArtifact && screenshotArtifact.screenshot) {
+      screenshotPath = screenshotArtifact.screenshot;
+    }
+  } else if (artifacts.screenshot) {
+    screenshotPath = artifacts.screenshot;
+  }
+
+  if (screenshotPath && fs.existsSync(screenshotPath)) {
+    const truncatedPath = truncate(String(screenshotPath), 250);
+    if (step.artifacts && Array.isArray(step.artifacts)) {
+      step.artifacts.push(truncatedPath);
+    } else {
+      step.artifacts = [truncatedPath];
+    }
+  }
+
+  return step;
+}
+
+/**
+ * Appends one artifact path to a step.
+ *
+ * Unlike addArtifactsToStep, this helper accepts a direct path (or URL-like string)
+ * and does not check file existence, so callers can attach fallback artifacts
+ * collected from logs or async trace outputs.
+ *
+ * @param {Object} step - Step object to update (modified in place)
+ * @param {string} artifactPath - Artifact path to append
+ * @returns {Object} The same step object with updated artifacts
+ */
+export function addArtifactPathToStep(step, artifactPath) {
+  if (!step || !artifactPath) return step;
+
+  const truncatedPath = truncate(String(artifactPath), 250);
+  if (step.artifacts && Array.isArray(step.artifacts)) {
+    if (!step.artifacts.includes(truncatedPath)) step.artifacts.push(truncatedPath);
+  } else {
+    step.artifacts = [truncatedPath];
+  }
+
+  return step;
+}

package/src/adapter/vitest.js

@@ -23,10 +23,14 @@ class VitestReporter {
      * @type {(TestData & {status: string})[]} tests
      */
     this.tests = [];
+    this._finalized = false;
+    this._finalizing = false;
   }
 
   // on run start
   onInit() {
+    this._finalized = false;
+    this._finalizing = false;
     this.client.createRun();
   }
 
@@ -35,34 +39,59 @@ class VitestReporter {
    * @param {unknown[] | undefined} errors // errors does not contain errors from tests; probably its testrunner errors
    */
   async onFinished(files, errors) {
-    if (!files || !files.length) console.info('No tests executed');
+    if (this._finalized || this._finalizing) return;
+    this._finalizing = true;
+
+    try {
+      this.tests = [];
+      if (!files || !files.length) {
+        console.info('No tests executed');
+        return;
+      }
 
-    files.forEach(file => {
-      // task could be test or suite
-      file.tasks.forEach(taskOrSuite => {
-        if (taskOrSuite.type === 'test') {
-          const test = taskOrSuite;
-          this.tests.push(this.#getDataFromTest(test));
-        } else if (taskOrSuite.type === 'suite') {
-          const suite = taskOrSuite;
-          this.#processTasksOfSuite(suite);
-        } else {
-          throw new Error('Unprocessed case. Unknown task type');
-        }
+      files.forEach(file => {
+        // task could be test or suite
+        getTasks(file).forEach(taskOrSuite => {
+          if (taskOrSuite.type === 'test') {
+            const test = taskOrSuite;
+            this.tests.push(this.#getDataFromTest(test));
+          } else if (taskOrSuite.type === 'suite') {
+            const suite = taskOrSuite;
+            this.#processTasksOfSuite(suite);
+          } else {
+            throw new Error('Unprocessed case. Unknown task type');
+          }
+        });
       });
-    });
 
-    debug(this.tests.length, 'tests collected');
+      debug(this.tests.length, 'tests collected');
 
-    // send tests to Testomat.io
-    for (const test of this.tests) {
-      await this.client.addTestRun(test.status, test);
-    }
+      // send tests to Testomat.io
+      for (const test of this.tests) {
+        await this.client.addTestRun(test.status, test);
+      }
 
-    console.log('finished');
-    if (errors.length) console.error('Vitest adapter errors:', errors);
+      console.log('finished');
+      if (errors.length) console.error('Vitest adapter errors:', errors);
 
-    await this.client.updateRunStatus(getRunStatusFromResults(files));
+      await this.client.updateRunStatus(getRunStatusFromResults(files));
+      this._finalized = true;
+    } finally {
+      this._finalizing = false;
+    }
+  }
+
+  /**
+   * Vitest 4+ reporter API callback.
+   *
+   * @param {Array<unknown> | undefined} testModules
+   * @param {unknown[] | undefined} errors
+   */
+  async onTestRunEnd(testModules, errors) {
+    const files = (testModules || [])
+      .map(module => module && (/** @type {any} */ (module).task || module))
+      .filter(Boolean);
+    await this.onFinished(files, errors);
   }
 
   /* non-used listeners
@@ -83,7 +112,7 @@ class VitestReporter {
    * @param {VitestSuite} suite
    */
   #processTasksOfSuite(suite) {
-    suite.tasks.forEach(taskOrSuite => {
+    getTasks(suite).forEach(taskOrSuite => {
       if (taskOrSuite.type === 'test') {
         const test = taskOrSuite;
         this.tests.push(this.#getDataFromTest(test));
@@ -106,12 +135,12 @@ class VitestReporter {
   #getDataFromTest(test) {
     return {
       error: test.result?.errors ? test.result.errors[0] : undefined,
-      file: test.file.name,
+      file: test.file?.name || test.file?.filepath || '',
       logs: test.logs ? transformLogsToString(test.logs) : '',
       meta: test.meta,
       // @ts-ignore - STATUS values are string literals but type system sees them as string
       status: getTestStatus(test),
-      suite_title: test.suite.name || test.file?.name,
+      suite_title: test.suite?.name || test.file?.name || test.file?.filepath,
       test_id: getTestomatIdFromTestTitle(test.name),
       time: test.result?.duration || 0,
       title: test.name,
@@ -162,8 +191,9 @@ function getRunStatusFromResults(files) {
 function getTestStatus(test) {
   if (test.result?.state === 'fail') return STATUS.FAILED;
   if (test.result?.state === 'pass') return STATUS.PASSED;
-  if (!test.result && test.mode === 'skip') return STATUS.SKIPPED;
+  if (test.result?.state === 'skip' || (!test.result && test.mode === 'skip')) return STATUS.SKIPPED;
   console.error(pc.red('Unprocessed case for defining test status. Contact dev team. Test:'), test);
+  return STATUS.SKIPPED;
 }
 
 /**
@@ -180,5 +210,19 @@ function transformLogsToString(logs) {
   return logsStr;
 }
 
+/**
+ * Supports both old and new Vitest task tree shapes.
+ *
+ * @param {any} node
+ * @returns {any[]}
+ */
+function getTasks(node) {
+  if (!node) return [];
+  if (Array.isArray(node.tasks)) return node.tasks;
+  if (Array.isArray(node.children)) return node.children;
+  if (node.task) return [node.task];
+  return [];
+}
+
 export default VitestReporter;
 export { VitestReporter };