@tiden/reporter-commons 0.1.0

package/dist/utils/test-status-utils.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineTestStatus = determineTestStatus;
+const test_execution_1 = require("../models/test-execution");
+/**
+ * Determines test status based on error type
+ * @param error - Error object or null
+ * @param originalStatus - Original test status from test runner
+ * @returns TestStatusEnum - failed for assertion errors, invalid for other errors
+ */
+function determineTestStatus(error, originalStatus) {
+    // If no error, return the original status
+    if (!error) {
+        return mapOriginalStatus(originalStatus);
+    }
+    // When the test runner explicitly reports timeout or interruption,
+    // treat as failed regardless of error content.
+    // (e.g. Playwright's timedOut/interrupted statuses)
+    const normalizedStatus = originalStatus.toLowerCase();
+    if (normalizedStatus === 'timedout' || normalizedStatus === 'interrupted') {
+        return test_execution_1.TestStatusEnum.failed;
+    }
+    // Check if it's an assertion error
+    if (isAssertionError(error, originalStatus)) {
+        return test_execution_1.TestStatusEnum.failed;
+    }
+    // For all other errors, return invalid
+    return test_execution_1.TestStatusEnum.invalid;
+}
+/**
+ * Checks if error is an assertion error
+ * @param error - Error object
+ * @param originalStatus - Original test status from test runner
+ * @returns boolean - true if assertion error
+ */
+function isAssertionError(error, originalStatus) {
+    const errorMessage = error.message.toLowerCase();
+    const errorStack = error.stack?.toLowerCase() || '';
+    const normalizedOriginalStatus = originalStatus.toLowerCase();
+    // Common assertion error patterns
+    const assertionPatterns = [
+        'expect',
+        'assert',
+        'matcher',
+        'objectcontaining',
+        'assertion',
+        'expected',
+        'actual',
+        'to be',
+        'to equal',
+        'to contain',
+        'to match',
+        'to throw',
+        'to be called',
+        'to have been called',
+        'test failed',
+        'expectation failed',
+        'assertion failed'
+    ];
+    // Non-assertion error patterns that should be invalid
+    const nonAssertionPatterns = [
+        'syntaxerror',
+        'referenceerror',
+        'typeerror',
+        'network',
+        'timeout',
+        'connection',
+        'http',
+        'fetch',
+        'axios',
+        'cors',
+        'permission',
+        'access denied',
+        'unauthorized',
+        'forbidden',
+        'not found',
+        'server error',
+        'internal error'
+    ];
+    // Special case: timeout errors with expect should be treated as assertion errors
+    const isTimeoutWithExpect = errorMessage.includes('timeout') &&
+        errorMessage.includes('expect');
+    if (isTimeoutWithExpect) {
+        return true;
+    }
+    // Check for non-assertion patterns (excluding timeout for special handling above)
+    const nonAssertionPatternsWithoutTimeout = nonAssertionPatterns.filter(pattern => pattern !== 'timeout');
+    const hasNonAssertionPattern = nonAssertionPatternsWithoutTimeout.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
+    // Cypress retry-ability prefix: "Timed out retrying after Nms:" is added by
+    // Cypress' retry mechanism exclusively for DOM-interacting commands (cy.get,
+    // cy.click, cy.should, cy.wait with aliases). It never appears in infra
+    // failures (cy.request, cy.task). This is the most reliable Cypress signal.
+    const isCypressRetryTimeout = /timed out retrying after \d+ms/.test(errorMessage);
+    if (hasNonAssertionPattern) {
+        const hasAssertionContext = assertionPatterns.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
+        const isRunnerFailed = normalizedOriginalStatus === 'failed' || normalizedOriginalStatus === 'timedout' || normalizedOriginalStatus === 'interrupted';
+        const isSyntaxError = errorMessage.includes('syntaxerror') || errorStack.includes('syntaxerror');
+        // When runner reported failure and error has assertion context (expect, ObjectContaining, diff),
+        // treat as Failed. Exception: SyntaxError (e.g. "Unexpected token") contains "expected" as false positive.
+        if (isRunnerFailed && hasAssertionContext && !isSyntaxError) {
+            return true;
+        }
+        // Cypress override: the retry-ability prefix is a strong signal that the
+        // test was actively interacting with the application via a retryable command.
+        // Cypress errors false-positive on "http" because (a) browser stack traces
+        // contain URLs and (b) all error messages include docs links
+        // (https://on.cypress.io/...). The retry prefix itself is never
+        // infrastructure, so we trust it unconditionally.
+        if (isCypressRetryTimeout && isRunnerFailed) {
+            return true;
+        }
+        return false;
+    }
+    // Cypress failure without any non-assertion pattern (clean stack trace)
+    if (isCypressRetryTimeout) {
+        return true;
+    }
+    // For timeout errors without expect, treat as invalid
+    if (errorMessage.includes('timeout')) {
+        return false;
+    }
+    // Check error message and stack for assertion patterns
+    const hasAssertionPattern = assertionPatterns.some(pattern => errorMessage.includes(pattern) || errorStack.includes(pattern));
+    // Check for specific error types that indicate assertions
+    const isJestMatcherError = error.name === 'Error' &&
+        (errorMessage.includes('expect') || errorMessage.includes('matcher'));
+    const isChaiAssertionError = error.name === 'AssertionError';
+    const isPlaywrightAssertionError = error.name === 'Error' &&
+        (errorMessage.includes('expect') || errorMessage.includes('assert'));
+    return hasAssertionPattern || isJestMatcherError || isChaiAssertionError || isPlaywrightAssertionError;
+}
+/**
+ * Maps original test runner status to TestStatusEnum
+ * @param originalStatus - Original status from test runner
+ * @returns TestStatusEnum
+ */
+function mapOriginalStatus(originalStatus) {
+    // Keys must be lowercase to match normalizedStatus (case-insensitive matching)
+    const statusMap = {
+        'passed': test_execution_1.TestStatusEnum.passed,
+        'failed': test_execution_1.TestStatusEnum.failed,
+        'skipped': test_execution_1.TestStatusEnum.skipped,
+        'disabled': test_execution_1.TestStatusEnum.disabled,
+        'pending': test_execution_1.TestStatusEnum.skipped,
+        'todo': test_execution_1.TestStatusEnum.disabled,
+        'focused': test_execution_1.TestStatusEnum.passed,
+        'timedout': test_execution_1.TestStatusEnum.failed,
+        'interrupted': test_execution_1.TestStatusEnum.failed,
+    };
+    const normalizedStatus = originalStatus.toLowerCase();
+    return statusMap[normalizedStatus] || test_execution_1.TestStatusEnum.skipped;
+}

package/dist/utils/tiden-error.d.ts

@@ -0,0 +1,18 @@
+export interface ErrorOptionsType {
+    cause?: unknown;
+}
+export interface TidenErrorInterface extends Error {
+    cause?: unknown;
+}
+/**
+ * @class TidenError
+ * @extends Error
+ * @implements TidenErrorInterface
+ */
+export declare class TidenError extends Error implements TidenErrorInterface {
+    /**
+     * @type {unknown}
+     */
+    cause?: unknown;
+    constructor(message?: string, options?: ErrorOptionsType);
+}

package/dist/utils/tiden-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TidenError = void 0;
+/**
+ * @class TidenError
+ * @extends Error
+ * @implements TidenErrorInterface
+ */
+class TidenError extends Error {
+    /**
+     * @type {unknown}
+     */
+    cause;
+    constructor(message, options) {
+        super(message);
+        this.cause = options?.cause;
+    }
+}
+exports.TidenError = TidenError;

package/dist/utils/token-masker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mask a token for safe logging.
+ * Tokens with 7 chars or fewer are fully masked. Longer tokens expose only
+ * the first 3 and last 4 characters.
+ */
+export declare function maskToken(token: string): string;
+/**
+ * Produce a deep-cloned copy of options with `tiden.api.token` masked.
+ * Safe to log — never mutates the input.
+ */
+export declare function sanitizeOptionsForLog<T>(options: T): T;

package/dist/utils/token-masker.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskToken = maskToken;
+exports.sanitizeOptionsForLog = sanitizeOptionsForLog;
+/**
+ * Mask a token for safe logging.
+ * Tokens with 7 chars or fewer are fully masked. Longer tokens expose only
+ * the first 3 and last 4 characters.
+ */
+function maskToken(token) {
+    if (token.length <= 7) {
+        return '*'.repeat(token.length);
+    }
+    return `${token.slice(0, 3)}****${token.slice(-4)}`;
+}
+/**
+ * Produce a deep-cloned copy of options with `tiden.api.token` masked.
+ * Safe to log — never mutates the input.
+ */
+function sanitizeOptionsForLog(options) {
+    const sanitized = JSON.parse(JSON.stringify(options));
+    if (sanitized.tiden?.api?.token) {
+        sanitized.tiden.api.token = maskToken(sanitized.tiden.api.token);
+    }
+    return sanitized;
+}

package/dist/utils/validate-json.d.ts

@@ -0,0 +1,20 @@
+import { ErrorObject, JSONSchemaType } from 'ajv';
+/**
+ * @class JsonValidationError
+ * @extends Error
+ */
+export declare class JsonValidationError extends Error {
+    validationErrors: ErrorObject[];
+    /**
+     * @param {ErrorObject[]} validationErrors
+     * @param {string} message
+     */
+    constructor(validationErrors: ErrorObject[], message?: string);
+}
+/**
+ * @template T
+ * @param {JSONSchemaType<T>} schema
+ * @param json
+ * @returns {asserts json is T}
+ */
+export declare function validateJson<T>(schema: JSONSchemaType<T>, json: unknown): asserts json is T;

package/dist/utils/validate-json.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonValidationError = void 0;
+exports.validateJson = validateJson;
+const ajv_1 = __importDefault(require("ajv"));
+/**
+ * @type {Ajv}
+ */
+const validator = new ajv_1.default({
+    allowUnionTypes: true,
+});
+/**
+ * @class JsonValidationError
+ * @extends Error
+ */
+class JsonValidationError extends Error {
+    validationErrors;
+    /**
+     * @param {ErrorObject[]} validationErrors
+     * @param {string} message
+     */
+    constructor(validationErrors, message) {
+        super(message);
+        this.validationErrors = validationErrors;
+    }
+}
+exports.JsonValidationError = JsonValidationError;
+/**
+ * @template T
+ * @param {JSONSchemaType<T>} schema
+ * @param json
+ * @returns {asserts json is T}
+ */
+function validateJson(schema, json) {
+    if (!validator.validate(schema, json)) {
+        throw new JsonValidationError(validator.errors ? [...validator.errors] : []);
+    }
+}

package/dist/writer/driver-enum.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @enum {string}
+ */
+export declare enum DriverEnum {
+    local = "local"
+}
+/**
+ * @enum {string}
+ */
+export declare enum FormatEnum {
+    json = "json",
+    jsonp = "jsonp"
+}

package/dist/writer/driver-enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatEnum = exports.DriverEnum = void 0;
+/**
+ * @enum {string}
+ */
+var DriverEnum;
+(function (DriverEnum) {
+    DriverEnum["local"] = "local";
+})(DriverEnum || (exports.DriverEnum = DriverEnum = {}));
+/**
+ * @enum {string}
+ */
+var FormatEnum;
+(function (FormatEnum) {
+    FormatEnum["json"] = "json";
+    FormatEnum["jsonp"] = "jsonp";
+})(FormatEnum || (exports.FormatEnum = FormatEnum = {}));

package/dist/writer/fs-writer.d.ts

@@ -0,0 +1,40 @@
+import { WriterInterface } from './writer-interface';
+import { TestResultType, Attachment, Report } from '../models';
+import { FormatEnum } from './driver-enum';
+export interface FsWriterOptionsType {
+    path?: string | undefined;
+    format?: FormatEnum | undefined;
+}
+/**
+ * @class FsWriter
+ * @implements WriterInterface
+ */
+export declare class FsWriter implements WriterInterface {
+    private readonly path;
+    private readonly format;
+    private formatter;
+    /**
+     * @param {FsWriterOptionsType | undefined} options
+     */
+    constructor(options: FsWriterOptionsType | undefined);
+    /**
+     * @returns {void}
+     */
+    clearPreviousResults(): void;
+    /**
+     * @param {Attachment[]} attachments
+     * @returns {Attachment[]}
+     */
+    writeAttachment(attachments: Attachment[]): Attachment[];
+    /**
+     * @param {TestResultType[]} results
+     * @returns {Promise<string>}
+     */
+    writeReport(results: Report): Promise<string>;
+    /**
+     * @returns {Promise<void>}
+     * @param {TestResultType} result
+     */
+    writeTestResult(result: TestResultType): Promise<void>;
+    private deleteFolderRecursive;
+}

package/dist/writer/fs-writer.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsWriter = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const formatter_1 = require("../formatter");
+const driver_enum_1 = require("./driver-enum");
+/**
+ * @class FsWriter
+ * @implements WriterInterface
+ */
+class FsWriter {
+    path;
+    format;
+    formatter;
+    /**
+     * @param {FsWriterOptionsType | undefined} options
+     */
+    constructor(options) {
+        const { path: pathOptions = path.join('build', 'tiden-report'), format = options?.format ?? driver_enum_1.FormatEnum.json, } = options ?? {};
+        this.path = pathOptions;
+        this.format = format;
+        if (this.format === driver_enum_1.FormatEnum.json) {
+            this.formatter = new formatter_1.JsonFormatter();
+        }
+        else {
+            this.formatter = new formatter_1.JsonpFormatter();
+        }
+    }
+    /**
+     * @returns {void}
+     */
+    clearPreviousResults() {
+        this.deleteFolderRecursive(this.path);
+    }
+    /**
+     * @param {Attachment[]} attachments
+     * @returns {Attachment[]}
+     */
+    writeAttachment(attachments) {
+        const attachmentsPath = path.join(this.path, 'attachments');
+        try {
+            (0, fs_1.mkdirSync)(attachmentsPath, { recursive: true });
+        }
+        catch (error) { /* ignore */
+        }
+        for (const attachment of attachments) {
+            if (attachment.file_path) {
+                attachment.file_name = path.basename(attachment.file_path);
+            }
+            const filePath = path.join(attachmentsPath, `${attachment.id}-${attachment.file_name}`);
+            if (attachment.file_path) {
+                (0, fs_1.copyFileSync)(attachment.file_path, filePath);
+                attachment.file_path = filePath;
+                continue;
+            }
+            (0, fs_1.writeFileSync)(filePath, attachment.content);
+            attachment.file_path = filePath;
+        }
+        return attachments;
+    }
+    /**
+     * @param {TestResultType[]} results
+     * @returns {Promise<string>}
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async writeReport(results) {
+        try {
+            (0, fs_1.mkdirSync)(this.path, { recursive: true });
+        }
+        catch (error) { /* ignore */
+        }
+        const filePath = path.join(this.path, `run.${this.format}`);
+        (0, fs_1.writeFileSync)(filePath, await this.formatter.format(results));
+        return filePath;
+    }
+    /**
+     * @returns {Promise<void>}
+     * @param {TestResultType} result
+     */
+    async writeTestResult(result) {
+        const resultsPath = path.join(this.path, 'results');
+        try {
+            (0, fs_1.mkdirSync)(resultsPath, { recursive: true });
+        }
+        catch (error) { /* ignore */
+        }
+        const filePath = path.join(resultsPath, `${result.id}.${this.format}`);
+        (0, fs_1.writeFileSync)(filePath, await this.formatter.format(result));
+    }
+    deleteFolderRecursive(directoryPath) {
+        if ((0, fs_1.existsSync)(directoryPath)) {
+            (0, fs_1.readdirSync)(directoryPath).forEach((file) => {
+                const curPath = path.join(directoryPath, file);
+                if ((0, fs_1.lstatSync)(curPath).isDirectory()) { // recurse
+                    this.deleteFolderRecursive(curPath);
+                }
+                else { // delete file
+                    (0, fs_1.unlinkSync)(curPath);
+                }
+            });
+            (0, fs_1.rmdirSync)(directoryPath);
+        }
+    }
+}
+exports.FsWriter = FsWriter;

package/dist/writer/index.d.ts

@@ -0,0 +1,3 @@
+export { type WriterInterface } from './writer-interface';
+export { FsWriter, type FsWriterOptionsType } from './fs-writer';
+export { DriverEnum, FormatEnum } from './driver-enum';

package/dist/writer/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatEnum = exports.DriverEnum = exports.FsWriter = void 0;
+var fs_writer_1 = require("./fs-writer");
+Object.defineProperty(exports, "FsWriter", { enumerable: true, get: function () { return fs_writer_1.FsWriter; } });
+var driver_enum_1 = require("./driver-enum");
+Object.defineProperty(exports, "DriverEnum", { enumerable: true, get: function () { return driver_enum_1.DriverEnum; } });
+Object.defineProperty(exports, "FormatEnum", { enumerable: true, get: function () { return driver_enum_1.FormatEnum; } });

package/dist/writer/writer-interface.d.ts

@@ -0,0 +1,7 @@
+import { TestResultType, Attachment, Report } from '../models';
+export interface WriterInterface {
+    writeReport(results: Report): Promise<string>;
+    writeTestResult(result: TestResultType): Promise<void>;
+    writeAttachment(attachments: Attachment[]): Attachment[];
+    clearPreviousResults(): void;
+}

package/dist/writer/writer-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@tiden/reporter-commons",
+  "version": "0.1.0",
+  "description": "Tiden JS Reporters",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./profilers": {
+      "types": "./dist/profilers/index.d.ts",
+      "default": "./dist/profilers/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "default": "./dist/internal/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "profilers": [
+        "./dist/profilers/index.d.ts"
+      ],
+      "internal": [
+        "./dist/internal/index.d.ts"
+      ]
+    }
+  },
+  "homepage": "https://github.com/qase-tms/tiden-javascript",
+  "bugs": {
+    "url": "https://github.com/qase-tms/tiden-javascript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qase-tms/tiden-javascript.git",
+    "directory": "commons"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc --project tsconfig.build.json",
+    "lint": "eslint .",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "author": "Tiden Team <support@tiden.ai>",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "ajv": "^8.18.0",
+    "async-mutex": "~0.5.0",
+    "axios": "^1.16.0",
+    "chalk": "^4.1.2",
+    "env-schema": "^5.2.1",
+    "form-data": "^4.0.6",
+    "lodash.get": "^4.4.2",
+    "lodash.merge": "^4.6.2",
+    "lodash.mergewith": "^4.6.2",
+    "mime-types": "^2.1.35",
+    "strip-ansi": "^6.0.1",
+    "uuid": "11.1.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.14",
+    "@types/lodash.get": "^4.4.9",
+    "@types/lodash.merge": "^4.6.9",
+    "@types/lodash.mergewith": "^4.6.9",
+    "@types/mime-types": "^2.1.4",
+    "@types/minimatch": "^6.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.5"
+  }
+}