@tiden/reporter-commons 0.1.0

package/dist/utils/get-package-version.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = void 0;
+const fs_1 = require("fs");
+/**
+ * @param {string} name
+ * @returns {undefined | string}
+ */
+const getPackageVersion = (name) => {
+    try {
+        const pathToPackageJson = require.resolve(`${name}/package.json`, {
+            paths: [process.cwd()],
+        });
+        const packageString = (0, fs_1.readFileSync)(pathToPackageJson, 'utf8');
+        const packageObject = JSON.parse(packageString);
+        if (typeof packageObject === 'object' &&
+            packageObject &&
+            'version' in packageObject) {
+            return String(packageObject.version);
+        }
+    }
+    catch { /* ignore */ }
+    return undefined;
+};
+exports.getPackageVersion = getPackageVersion;

package/dist/utils/hostData.d.ts

@@ -0,0 +1,8 @@
+import { HostData } from '../models/host-data';
+/**
+ * Gets information about the current host environment
+ * @param {string} framework The framework name to check version for
+ * @param {string} reporterName The reporter name to check version for
+ * @returns {HostData} Host information object
+ */
+export declare function getHostInfo(framework: string, reporterName: string): HostData;

package/dist/utils/hostData.js

@@ -0,0 +1,140 @@
+"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.getHostInfo = getHostInfo;
+const os = __importStar(require("os"));
+const cp = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const get_package_version_1 = require("./get-package-version");
+/**
+ * Normalizes platform name to unified format
+ * @param {string} platform - process.platform value
+ * @returns {string} Normalized platform name
+ */
+function normalizePlatform(platform) {
+    if (platform === 'win32')
+        return 'windows';
+    return platform;
+}
+/**
+ * Gets detailed OS information based on the platform
+ * @returns {string} Detailed OS information
+ */
+function getDetailedOSInfo() {
+    const platform = process.platform;
+    try {
+        if (platform === 'win32') {
+            // Windows
+            return cp.execSync('ver').toString().trim();
+        }
+        else if (platform === 'darwin') {
+            // macOS
+            return cp.execSync('sw_vers -productVersion').toString().trim();
+        }
+        else {
+            // Linux and others
+            try {
+                const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+                const prettyName = osRelease.match(/PRETTY_NAME="(.+)"/);
+                if (prettyName?.[1]) {
+                    return prettyName[1];
+                }
+            }
+            catch {
+                // Fallback if /etc/os-release doesn't exist or can't be read
+            }
+            return os.release();
+        }
+    }
+    catch (error) {
+        console.error('Error getting detailed OS info:', error);
+        return os.release();
+    }
+}
+/**
+ * Gets npm version from environment or by executing npm command
+ * @returns {string} npm version string
+ */
+function getNpmVersion() {
+    const userAgent = process.env['npm_config_user_agent'];
+    if (userAgent) {
+        const match = userAgent.match(/^npm\/(\S+)/);
+        if (match?.[1]) {
+            return match[1];
+        }
+    }
+    try {
+        return cp.execSync('npm --version', { stdio: 'pipe' }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Gets information about the current host environment
+ * @param {string} framework The framework name to check version for
+ * @param {string} reporterName The reporter name to check version for
+ * @returns {HostData} Host information object
+ */
+function getHostInfo(framework, reporterName) {
+    try {
+        return {
+            system: normalizePlatform(process.platform),
+            machineName: os.hostname(),
+            release: os.release(),
+            version: getDetailedOSInfo(),
+            arch: os.arch(),
+            language: process.version,
+            packageManager: getNpmVersion(),
+            framework: (0, get_package_version_1.getPackageVersion)(framework) ?? '',
+            reporter: (0, get_package_version_1.getPackageVersion)(reporterName) ?? '',
+            commons: (0, get_package_version_1.getPackageVersion)('@tiden/reporter-commons') ?? '',
+        };
+    }
+    catch (error) {
+        return {
+            system: normalizePlatform(process.platform),
+            machineName: os.hostname() || '',
+            release: os.release(),
+            version: '',
+            arch: os.arch(),
+            language: '',
+            packageManager: '',
+            framework: '',
+            reporter: '',
+            commons: '',
+        };
+    }
+}

package/dist/utils/is-axios-error.d.ts

@@ -0,0 +1,6 @@
+import { AxiosError } from 'axios';
+/**
+ * @param error
+ * @returns {error is AxiosError}
+ */
+export declare const isAxiosError: (error: unknown) => error is AxiosError;

package/dist/utils/is-axios-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAxiosError = void 0;
+/**
+ * @param error
+ * @returns {error is AxiosError}
+ */
+const isAxiosError = (error) => error instanceof Error
+    && 'isAxiosError' in error
+    && Boolean(error.isAxiosError);
+exports.isAxiosError = isAxiosError;

package/dist/utils/logger.d.ts

@@ -0,0 +1,33 @@
+export interface LoggerInterface {
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+}
+export declare class Logger implements LoggerInterface {
+    private readonly debug;
+    private readonly filePath;
+    private readonly consoleEnabled;
+    private readonly fileEnabled;
+    constructor(options: {
+        debug?: boolean | undefined;
+        dir?: string;
+        consoleLogging?: boolean | undefined;
+        fileLogging?: boolean | undefined;
+    });
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+    private logToFile;
+    private doLogError;
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    private logApiError;
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    private formatErrorFields;
+}

package/dist/utils/logger.js

@@ -0,0 +1,141 @@
+"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.Logger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const is_axios_error_1 = require("./is-axios-error");
+const tiden_error_1 = require("./tiden-error");
+class Logger {
+    debug;
+    filePath;
+    consoleEnabled;
+    fileEnabled;
+    constructor(options) {
+        this.debug = options.debug;
+        // Determine console logging: if explicitly set, use that value; otherwise default to true
+        this.consoleEnabled = options.consoleLogging !== undefined ? options.consoleLogging : true;
+        // Determine file logging: if explicitly set, use that value; otherwise use debug setting
+        this.fileEnabled = options.fileLogging !== undefined ? options.fileLogging : (this.debug ?? false);
+        const dir = options.dir ?? './logs';
+        if (this.fileEnabled && !fs.existsSync(dir)) {
+            fs.mkdirSync(dir);
+        }
+        this.filePath = path.join(dir, 'log.txt');
+    }
+    log(message) {
+        const logMessage = `[INFO] tiden: ${message}`;
+        if (this.consoleEnabled) {
+            console.log(logMessage);
+        }
+        if (this.fileEnabled) {
+            this.logToFile(logMessage);
+        }
+    }
+    logError(message, error) {
+        const logMessage = `[ERROR] tiden: ${this.doLogError(message, error)}`;
+        if (this.consoleEnabled) {
+            console.error(logMessage);
+        }
+        if (this.fileEnabled) {
+            this.logToFile(logMessage);
+        }
+    }
+    logDebug(message) {
+        if (this.debug) {
+            const logMessage = `[DEBUG] tiden: ${message}`;
+            if (this.consoleEnabled) {
+                console.log(logMessage);
+            }
+            if (this.fileEnabled) {
+                this.logToFile(logMessage);
+            }
+        }
+    }
+    logToFile(message) {
+        const formattedMessage = `[${new Date().toISOString()}] ${message}\n`;
+        fs.appendFileSync(this.filePath, formattedMessage);
+    }
+    doLogError(message, error) {
+        let logMessage = message;
+        if (error instanceof Error) {
+            if ((0, is_axios_error_1.isAxiosError)(error)) {
+                logMessage += this.logApiError(error);
+            }
+            else if (error instanceof tiden_error_1.TidenError && error.cause) {
+                logMessage += this.doLogError('\n Caused by:', error.cause);
+            }
+            logMessage += `\n ${error.stack ?? `${error.name}: ${error.message}`}`;
+        }
+        else {
+            logMessage += `\n ${String(error)}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    logApiError(error) {
+        if (!error.response?.data) {
+            return `\nMessage: ${error.message || 'Unknown error'}`;
+        }
+        const response = error.response.data;
+        const statusText = error.response.statusText;
+        const errorMessage = response.errorMessage
+            ?? response.error
+            ?? statusText;
+        const errorFields = this.formatErrorFields(response.errorFields);
+        let logMessage = `\nMessage: ${errorMessage}`;
+        if (errorFields) {
+            logMessage += `\n${errorFields}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    formatErrorFields(errorFields) {
+        if (!errorFields?.length) {
+            return undefined;
+        }
+        return errorFields
+            .map(({ field, error }) => `${field}: ${error}`)
+            .join('\n');
+    }
+}
+exports.Logger = Logger;

package/dist/utils/mimeTypes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get mime type of the file
+ * @param {string} filePath
+ */
+export declare function getMimeTypes(filePath: string): string;

package/dist/utils/mimeTypes.js

@@ -0,0 +1,50 @@
+"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.getMimeTypes = getMimeTypes;
+const path = __importStar(require("path"));
+const mime = __importStar(require("mime-types"));
+/**
+ * Get mime type of the file
+ * @param {string} filePath
+ */
+function getMimeTypes(filePath) {
+    const fileName = path.basename(filePath);
+    const mimeType = mime.contentType(fileName);
+    if (!mimeType && typeof mimeType !== 'string') {
+        return 'application/octet-stream';
+    }
+    return mimeType;
+}

package/dist/utils/project-mapping-utils.d.ts

@@ -0,0 +1,17 @@
+import { LoggerInterface } from './logger';
+/**
+ * Result of parsing "(Tiden ID: n)" markers from a test title.
+ * - legacyIds: from "(Tiden ID: 123)" or "(Tiden ID: 123,124)".
+ * - cleanedTitle: title with all such patterns removed.
+ */
+export interface ParsedTidenId {
+    legacyIds: number[];
+    cleanedTitle: string;
+}
+/**
+ * Parse "(Tiden ID: …)" markers from a test title.
+ *
+ * @param title — test title that may contain "(Tiden ID: …)".
+ * @returns legacyIds and cleanedTitle with all markers stripped.
+ */
+export declare function parseTidenIdFromTitle(title: string, logger?: LoggerInterface): ParsedTidenId;

package/dist/utils/project-mapping-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTidenIdFromTitle = parseTidenIdFromTitle;
+const filter_positive_ids_1 = require("../internal/filter-positive-ids");
+/** Matches "(Tiden ID: 123)" or "(Tiden ID: 123,124)". Allows negative numbers. */
+const TIDEN_ID_MARKER_REGEXP = /\(Tiden\s+ID:\s*([-\d,]+)\)/gi;
+/**
+ * Parse "(Tiden ID: …)" markers from a test title.
+ *
+ * @param title — test title that may contain "(Tiden ID: …)".
+ * @returns legacyIds and cleanedTitle with all markers stripped.
+ */
+function parseTidenIdFromTitle(title, logger) {
+    const legacyIds = [];
+    let cleanedTitle = title;
+    let m;
+    const re = new RegExp(TIDEN_ID_MARKER_REGEXP.source, 'gi');
+    while ((m = re.exec(title)) !== null) {
+        const idsStr = m[1] ?? '';
+        const rawIds = idsStr
+            .split(',')
+            .map((s) => parseInt(s, 10))
+            .filter((n) => !Number.isNaN(n));
+        legacyIds.push(...(0, filter_positive_ids_1.filterPositiveIds)(rawIds, logger));
+        cleanedTitle = cleanedTitle.replace(m[0], '');
+    }
+    cleanedTitle = cleanedTitle.replace(/\s+/g, ' ').trim();
+    return { legacyIds, cleanedTitle };
+}

package/dist/utils/signature.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a signature string from case IDs and suites.
+ *
+ * Param-free by design: signature is the case-level identity input, kept
+ * stable across every parameter combination of a parametrized case. Params
+ * are hashed separately (at the attempt level) rather than folded in here.
+ * @param caseIds - Array of case IDs or null
+ * @param suites - Array of suite names
+ * @returns Formatted signature string
+ */
+export declare const generateSignature: (caseIds: number[] | null, suites: string[]) => string;

package/dist/utils/signature.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSignature = void 0;
+/**
+ * Generates a signature string from case IDs and suites.
+ *
+ * Param-free by design: signature is the case-level identity input, kept
+ * stable across every parameter combination of a parametrized case. Params
+ * are hashed separately (at the attempt level) rather than folded in here.
+ * @param caseIds - Array of case IDs or null
+ * @param suites - Array of suite names
+ * @returns Formatted signature string
+ */
+const generateSignature = (caseIds, suites) => {
+    const parts = [];
+    if (caseIds && caseIds.length > 0) {
+        parts.push(caseIds.join('-'));
+    }
+    if (suites.length > 0) {
+        const processedSuites = suites
+            .map(suite => suite.trim())
+            .map(suite => suite.replace(/\\/g, '/'))
+            .flatMap(suite => suite.split('::'))
+            .map(suite => suite.trim())
+            .flatMap(suite => suite.split('\t'))
+            .map(suite => suite.trim())
+            .map(suite => suite.replace(/\s+/g, '_'))
+            .map(suite => suite.toLowerCase())
+            .filter(suite => suite.length > 0);
+        parts.push(processedSuites.join('::'));
+    }
+    return parts.join('::');
+};
+exports.generateSignature = generateSignature;

package/dist/utils/status-mapping-utils.d.ts

@@ -0,0 +1,14 @@
+import { TestStatusEnum } from '../models/test-execution';
+/**
+ * Applies status mapping configuration to a test status
+ * @param status - Original test status
+ * @param statusMapping - Status mapping configuration
+ * @returns Mapped test status or original if no mapping found
+ */
+export declare function applyStatusMapping(status: TestStatusEnum, statusMapping?: Record<string, string>): TestStatusEnum;
+/**
+ * Validates status mapping configuration
+ * @param statusMapping - Status mapping configuration to validate
+ * @returns Array of validation errors (empty if valid)
+ */
+export declare function validateStatusMapping(statusMapping: Record<string, string>): string[];

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStatusMapping = applyStatusMapping;
+exports.validateStatusMapping = validateStatusMapping;
+const test_execution_1 = require("../models/test-execution");
+/**
+ * Applies status mapping configuration to a test status
+ * @param status - Original test status
+ * @param statusMapping - Status mapping configuration
+ * @returns Mapped test status or original if no mapping found
+ */
+function applyStatusMapping(status, statusMapping) {
+    if (!statusMapping) {
+        return status;
+    }
+    const mappedStatus = statusMapping[status];
+    if (!mappedStatus) {
+        return status;
+    }
+    // Validate that the mapped status is a valid TestStatusEnum value
+    const validStatuses = Object.values(test_execution_1.TestStatusEnum);
+    if (!validStatuses.includes(mappedStatus)) {
+        console.warn(`Invalid status mapping: "${status}" -> "${mappedStatus}". Valid statuses are: ${validStatuses.join(', ')}`);
+        return status;
+    }
+    return mappedStatus;
+}
+/**
+ * Validates status mapping configuration
+ * @param statusMapping - Status mapping configuration to validate
+ * @returns Array of validation errors (empty if valid)
+ */
+function validateStatusMapping(statusMapping) {
+    const errors = [];
+    const validStatuses = Object.values(test_execution_1.TestStatusEnum);
+    for (const [fromStatus, toStatus] of Object.entries(statusMapping)) {
+        if (!validStatuses.includes(fromStatus)) {
+            errors.push(`Invalid source status "${fromStatus}". Valid statuses are: ${validStatuses.join(', ')}`);
+        }
+        if (!validStatuses.includes(toStatus)) {
+            errors.push(`Invalid target status "${toStatus}". Valid statuses are: ${validStatuses.join(', ')}`);
+        }
+    }
+    return errors;
+}

package/dist/utils/test-status-utils.d.ts

@@ -0,0 +1,8 @@
+import { TestStatusEnum } from '../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
+ */
+export declare function determineTestStatus(error: Error | null, originalStatus: string): TestStatusEnum;