@testomatio/reporter 2.3.9-beta-bin-fix → 2.3.9

package/src/client.js

@@ -1,17 +1,15 @@
 import createDebugMessages from 'debug';
-import createCallsiteRecord from 'callsite-record';
-import { minimatch } from 'minimatch';
 import fs from 'fs';
 import pc from 'picocolors';
-import { randomUUID } from 'crypto';
 import { APP_PREFIX, STATUS } from './constants.js';
 import { pipesFactory } from './pipe/index.js';
 import { glob } from 'glob';
-import path, { sep } from 'path';
+import path from 'path';
 import { fileURLToPath } from 'node:url';
 import { S3Uploader } from './uploader.js';
-import { formatStep, truncate, readLatestRunId, storeRunId, validateSuiteId } from './utils/utils.js';
+import { readLatestRunId, storeRunId, validateSuiteId, transformEnvVarToBoolean } from './utils/utils.js';
 import { filesize as prettyBytes } from 'filesize';
+import { formatLogs, formatError, stripColors } from './utils/log-formatter.js';
 
 const debug = createDebugMessages('@testomatio/reporter:client');
 
@@ -110,7 +108,7 @@ class Client {
    *
    * @returns {Promise<any>} - resolves to Run id which should be used to update / add test
    */
-  async createRun(params) {
+  async createRun(params = {}) {
     if (!this.pipes || !this.pipes.length)
       this.pipes = await pipesFactory(params || this.paramsForPipesFactory || {}, this.pipeStore);
     debug('Creating run...');
@@ -118,7 +116,7 @@ class Client {
     if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
     this.queue = this.queue
-      .then(() => Promise.all(this.pipes.map(p => p.createRun())))
+      .then(() => Promise.all(this.pipes.map(p => p.createRun(params))))
       .catch(err => console.log(APP_PREFIX, err))
       .then(() => {
         const runId = this.pipeStore?.runId;
@@ -139,19 +137,6 @@ class Client {
    * @returns {Promise<PipeResult[]>}
    */
   async addTestRun(status, testData) {
-    if (!this.pipes || !this.pipes.length)
-      this.pipes = await pipesFactory(this.paramsForPipesFactory || {}, this.pipeStore);
-
-    // all pipes disabled, skipping
-    if (!this.pipes?.filter(p => p.isEnabled).length) return [];
-
-    if (isTestShouldBeExculedFromReport(testData)) return [];
-
-    if (status === STATUS.SKIPPED && process.env.TESTOMATIO_EXCLUDE_SKIPPED) {
-      debug('Skipping test from report', testData?.title);
-      return []; // do not log skipped tests
-    }
-
     if (!testData)
       testData = {
         title: 'Unknown test',
@@ -166,18 +151,19 @@ class Client {
     /**
      * @type {TestData}
      */
+    const { rid, error = null, steps: originalSteps, title, suite_title } = testData;
+    let steps = originalSteps;
+
+    const uploadedFiles = [];
+    const stackArtifactsEnabled = transformEnvVarToBoolean(process.env.TESTOMATIO_STACK_ARTIFACTS);
+
     const {
-      rid,
-      error = null,
       time = 0,
       example = null,
       files = [],
       filesBuffers = [],
-      steps,
       code = null,
-      title,
       file,
-      suite_title,
       suite_id,
       test_id,
       timestamp,
@@ -188,7 +174,6 @@ class Client {
     } = testData;
     let { message = '', meta = {} } = testData;
 
-    // stringify meta values and limit keys and values length to 255
     meta = Object.entries(meta)
       .filter(([, value]) => value !== null && value !== undefined)
       .reduce((acc, [key, value]) => {
@@ -196,22 +181,46 @@ class Client {
         return acc;
       }, {});
 
-    // Get links from storage using the test context
     const testContext = suite_title ? `${suite_title} ${title}` : title;
 
     let errorFormatted = '';
     if (error) {
-      errorFormatted += this.formatError(error) || '';
+      errorFormatted += formatError(error) || '';
       message = error?.message;
     }
 
-    // Attach logs
-    const fullLogs = this.formatLogs({ error: errorFormatted, steps, logs: testData.logs });
+    let fullLogs = formatLogs({ error: errorFormatted, steps, logs: testData.logs });
 
-    // add artifacts
-    if (manuallyAttachedArtifacts?.length) files.push(...manuallyAttachedArtifacts);
+    if (stackArtifactsEnabled && fullLogs?.trim()?.length > 0) {
+      uploadedFiles.push(
+        this.uploader.uploadFileAsBuffer(Buffer.from(stripColors(fullLogs), 'utf8'), [
+          this.runId,
+          rid,
+          `logs_${+new Date()}.log`,
+        ]),
+      );
+      fullLogs = '';
+      steps = null;
+    }
 
-    const uploadedFiles = [];
+    if (!this.pipes || !this.pipes.length)
+      this.pipes = await pipesFactory(this.paramsForPipesFactory || {}, this.pipeStore);
+
+    if (!this.pipes?.filter(p => p.isEnabled).length) {
+      if (uploadedFiles.length > 0) {
+        await Promise.all(uploadedFiles);
+      }
+      return [];
+    }
+
+    if (isTestShouldBeExcludedFromReport(testData)) return [];
+
+    if (status === STATUS.SKIPPED && process.env.TESTOMATIO_EXCLUDE_SKIPPED) {
+      debug('Skipping test from report', testData?.title);
+      return [];
+    }
+
+    if (manuallyAttachedArtifacts?.length) files.push(...manuallyAttachedArtifacts);
 
     for (let f of files) {
       if (!f) continue; // f === null
@@ -308,7 +317,7 @@ class Client {
           const uploadedArtifacts = this.uploader.successfulUploads.map(file => ({
             relativePath: file.path.replace(process.cwd(), ''),
             link: file.link,
-            sizePretty: prettyBytes(file.size, { round: 0 }).toString(),
+            sizePretty: file.size == null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
           }));
 
           uploadedArtifacts.forEach(upload => {
@@ -330,7 +339,7 @@ class Client {
           );
           const failedUploads = this.uploader.failedUploads.map(file => ({
             relativePath: file.path.replace(process.cwd(), ''),
-            sizePretty: prettyBytes(file.size, { round: 0 }).toString(),
+            sizePretty: file.size == null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
           }));
 
           const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
@@ -380,84 +389,6 @@ class Client {
 
     return this.queue;
   }
-
-  /**
-   * Returns the formatted stack including the stack trace, steps, and logs.
-   * @returns {string}
-   */
-  formatLogs({ error, steps, logs }) {
-    error = error?.trim();
-    logs = logs?.trim().split('\n').map(l => truncate(l)).join('\n');
-
-    if (Array.isArray(steps)) {
-      steps = steps
-        .map(step => formatStep(step))
-        .flat()
-        .join('\n');
-    }
-
-    let testLogs = '';
-    if (steps) testLogs += `${pc.bold(pc.blue('################[ Steps ]################'))}\n${steps}\n\n`;
-    if (logs) testLogs += `${pc.bold(pc.gray('################[ Logs ]################'))}\n${logs}\n\n`;
-    if (error) testLogs += `${pc.bold(pc.red('################[ Failure ]################'))}\n${error}`;
-    return testLogs;
-  }
-
-  formatError(error, message) {
-    if (!message) message = error.message;
-    if (error.inspect) message = error.inspect() || '';
-
-    let stack = '';
-    if (error.name) stack += `${pc.red(error.name)}`;
-    if (error.operator) stack += ` (${pc.red(error.operator)})`;
-    // add new line if something was added to stack
-    if (stack) stack += ': ';
-
-    stack += `${message}\n`;
-
-    if (error.diff) {
-      // diff for vitest
-      stack += error.diff;
-      stack += '\n\n';
-    } else if (error.actual && error.expected && error.actual !== error.expected) {
-      // diffs for mocha, cypress, codeceptjs style
-      stack += `\n\n${pc.bold(pc.green('+ expected'))} ${pc.bold(pc.red('- actual'))}`;
-      stack += `\n${pc.green(`+ ${error.expected.toString().split('\n').join('\n+ ')}`)}`;
-      stack += `\n${pc.red(`- ${error.actual.toString().split('\n').join('\n- ')}`)}`;
-      stack += '\n\n';
-    }
-
-    const customFilter = process.env.TESTOMATIO_STACK_IGNORE;
-
-    try {
-      let hasFrame = false;
-      const record = createCallsiteRecord({
-        forError: error,
-        isCallsiteFrame: frame => {
-          if (customFilter && minimatch(frame.fileName, customFilter)) return false;
-          if (hasFrame) return false;
-          if (isNotInternalFrame(frame)) hasFrame = true;
-          return hasFrame;
-        },
-      });
-      // @ts-ignore
-      if (record && !record.filename.startsWith('http')) {
-        stack += record.renderSync({ stackFilter: isNotInternalFrame });
-      }
-      return stack;
-    } catch (e) {
-      console.log(e);
-    }
-  }
-}
-
-function isNotInternalFrame(frame) {
-  return (
-    frame.getFileName() &&
-    frame.getFileName().includes(sep) &&
-    !frame.getFileName().includes('node_modules') &&
-    !frame.getFileName().includes('internal')
-  );
 }
 
 /**
@@ -465,7 +396,7 @@ function isNotInternalFrame(frame) {
  * @param {TestData} testData
  * @returns boolean
  */
-function isTestShouldBeExculedFromReport(testData) {
+function isTestShouldBeExcludedFromReport(testData) {
   // const fileName = path.basename(test.location?.file || '');
   const globExcludeFilesPattern = process.env.TESTOMATIO_EXCLUDE_FILES_FROM_REPORT_GLOB_PATTERN;
   if (!globExcludeFilesPattern) return false;
@@ -475,12 +406,12 @@ function isTestShouldBeExculedFromReport(testData) {
     return false;
   }
 
-  const excludeParretnsList = globExcludeFilesPattern.split(';');
+  const excludePatternsList = globExcludeFilesPattern.split(';');
 
   // as scanning files is time consuming operation, just save the result in variable to avoid multiple scans
   if (!listOfTestFilesToExcludeFromReport) {
     // list of files with relative paths
-    listOfTestFilesToExcludeFromReport = glob.sync(excludeParretnsList, { ignore: '**/node_modules/**' });
+    listOfTestFilesToExcludeFromReport = glob.sync(excludePatternsList, { ignore: '**/node_modules/**' });
     debug('Tests from next files will not be reported:', listOfTestFilesToExcludeFromReport);
   }
 

package/src/junit-adapter/csharp.js

@@ -3,18 +3,53 @@ import Adapter from './adapter.js';
 
 class CSharpAdapter extends Adapter {
   formatTest(t) {
-    const title = t.title.replace(/\(.*?\)/, '').trim();
-    const example = t.title.match(/\((.*?)\)/);
-    if (example) t.example = { ...example[1].split(',') };
+    // Extract example from title if not already present
+    if (!t.example) {
+      const exampleMatch = t.title.match(/\((.*?)\)/);
+      if (exampleMatch) {
+        // Extract parameters as object with numeric keys for API
+        const params = exampleMatch[1]
+          .split(',')
+          .map(param => param.trim())
+          .filter(param => param !== '');
+        t.example = {};
+        params.forEach((param, index) => {
+          t.example[index] = param;
+        });
+      }
+    }
+
+    // Remove parameters from title to avoid duplicates in Test Suite
+    // The example field will be used for grouping on import
+    t.title = t.title.replace(/\(.*?\)/, '').trim();
+
     const suite = t.suite_title.split('.');
     t.suite_title = suite.pop();
     t.file = namespaceToFileName(t.file);
-    t.title = title.trim();
     return t;
   }
 
   getFilePath(t) {
-    const fileName = namespaceToFileName(t.file);
+    if (!t.file) return null;
+
+    // Normalize path separators for cross-platform compatibility
+    let filePath = t.file.replace(/\\/g, '/');
+
+    // If file already has .cs extension, use it directly
+    if (filePath.endsWith('.cs')) {
+      // Make relative path if it's absolute
+      if (path.isAbsolute(filePath)) {
+        // Try to find project-relative path
+        const cwd = process.cwd().replace(/\\/g, '/');
+        if (filePath.startsWith(cwd)) {
+          filePath = path.relative(cwd, filePath).replace(/\\/g, '/');
+        }
+      }
+      return filePath;
+    }
+
+    // Convert namespace path to file path
+    const fileName = namespaceToFileName(filePath);
     return fileName;
   }
 }
@@ -22,7 +57,14 @@ class CSharpAdapter extends Adapter {
 export default CSharpAdapter;
 
 function namespaceToFileName(fileName) {
+  if (!fileName) return '';
+
+  // If already a .cs file path, clean it up
+  if (fileName.endsWith('.cs')) {
+    return fileName.replace(/\\/g, '/');
+  }
+
   const fileParts = fileName.split('.');
   fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
-  return `${fileParts.join(path.sep)}.cs`;
+  return `${fileParts.join('/')}.cs`;
 }