@tiden/reporter-commons 0.1.0

package/dist/client/services/attachment-service.js

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentService = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = require("fs");
+const is_axios_error_1 = require("../../utils/is-axios-error");
+const api_error_handler_1 = require("./api-error-handler");
+const MAX_FILE_SIZE = 32 * 1024 * 1024; // 32 MB per file
+const MAX_REQUEST_SIZE = 128 * 1024 * 1024; // 128 MB per request
+const MAX_FILES_PER_REQUEST = 20; // 20 files per request
+const BASE64_PATTERN = /^[A-Za-z0-9+/=]+$/;
+// The round-trip check only catches malformed/misplaced padding: ANY
+// complete, unpadded base64-alphabet string round-trips regardless of
+// length, so a plain word like "abcd" is indistinguishable from genuine
+// base64 by round-trip alone. This length floor is therefore the sole
+// heuristic separating short plain words from base64; 8 (two full groups)
+// keeps common words as utf8 at the cost of misreading genuinely
+// base64-encoded content shorter than 6 bytes as literal text — an
+// acceptable trade-off since real attachments are far larger.
+const MIN_BASE64_LENGTH = 8;
+/**
+ * Heuristically decide whether a string is base64-encoded content rather
+ * than plain utf8 text. Requires ALL of: base64-alphabet-only characters,
+ * a length that's a multiple of 4, a minimum length (see MIN_BASE64_LENGTH),
+ * and a decode/re-encode round-trip match (catches non-canonical padding).
+ */
+function looksLikeBase64(value) {
+    if (!BASE64_PATTERN.test(value))
+        return false;
+    if (value.length % 4 !== 0)
+        return false;
+    if (value.length < MIN_BASE64_LENGTH)
+        return false;
+    const normalize = (s) => s.replace(/=+$/, '');
+    const reencoded = Buffer.from(value, 'base64').toString('base64');
+    return normalize(reencoded) === normalize(value);
+}
+class AttachmentService {
+    logger;
+    http;
+    constructor(logger, http) {
+        this.logger = logger;
+        this.http = http;
+    }
+    async uploadAttachment(projectCode, attachment) {
+        try {
+            const data = this.prepareAttachmentData(attachment);
+            const response = await this.postAttachmentBatch(projectCode, [data]);
+            return response.data.result?.[0]?.hash ?? '';
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error on uploading attachment');
+        }
+    }
+    async uploadAttachments(projectCode, attachments, uploadEnabled) {
+        if (!uploadEnabled) {
+            return [];
+        }
+        const uploadedHashes = [];
+        const validAttachments = [];
+        for (const attachment of attachments) {
+            if (!attachment)
+                continue;
+            this.ensureAttachmentSize(attachment);
+            if (attachment.size === 0) {
+                this.logger.logError(`Cannot determine size for attachment "${attachment.file_path ?? attachment.file_name}". Skipping.`);
+                continue;
+            }
+            if (attachment.size > MAX_FILE_SIZE) {
+                this.logger.logError(`Attachment "${attachment.file_path ?? attachment.file_name}" exceeds maximum file size (32 MB). ` +
+                    `File size: ${(attachment.size / (1024 * 1024)).toFixed(2)} MB. Skipping.`);
+                continue;
+            }
+            validAttachments.push(attachment);
+        }
+        if (validAttachments.length === 0) {
+            return uploadedHashes;
+        }
+        const initialJitter = Math.random() * 500;
+        await this.delay(initialJitter);
+        const batches = this.groupIntoBatches(validAttachments);
+        this.logger.logDebug(`Uploading ${validAttachments.length} attachments in ${batches.length} batch(es)`);
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            if (!batch || batch.length === 0)
+                continue;
+            try {
+                const batchNames = batch.map(a => a.file_path ?? a.file_name).join(', ');
+                this.logger.logDebug(`Uploading batch ${i + 1}/${batches.length} with ${batch.length} file(s): ${batchNames}`);
+                const batchData = batch.map(a => this.prepareAttachmentData(a));
+                const response = await this.uploadWithRetry(projectCode, batchData, batchNames);
+                if (response.data.result) {
+                    for (const result of response.data.result) {
+                        if (result.hash) {
+                            uploadedHashes.push(result.hash);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.logError(`Cannot upload batch ${i + 1}:`, error);
+            }
+            if (i < batches.length - 1) {
+                const baseDelay = 1000;
+                const jitter = Math.random() * 300;
+                await this.delay(baseDelay + jitter);
+            }
+        }
+        return uploadedHashes;
+    }
+    groupIntoBatches(attachments) {
+        const batches = [];
+        let currentBatch = [];
+        let currentBatchSize = 0;
+        for (const attachment of attachments) {
+            const attachmentSize = attachment.size;
+            const wouldExceedFileLimit = currentBatch.length >= MAX_FILES_PER_REQUEST;
+            const wouldExceedSizeLimit = currentBatchSize + attachmentSize > MAX_REQUEST_SIZE;
+            if (wouldExceedFileLimit || wouldExceedSizeLimit) {
+                if (currentBatch.length > 0) {
+                    batches.push(currentBatch);
+                    currentBatch = [];
+                    currentBatchSize = 0;
+                }
+            }
+            if (attachmentSize > MAX_REQUEST_SIZE) {
+                this.logger.logError(`Attachment "${attachment.file_path ?? attachment.file_name}" exceeds maximum request size (128 MB). ` +
+                    `File size: ${(attachmentSize / (1024 * 1024)).toFixed(2)} MB. Skipping.`);
+                continue;
+            }
+            currentBatch.push(attachment);
+            currentBatchSize += attachmentSize;
+        }
+        if (currentBatch.length > 0) {
+            batches.push(currentBatch);
+        }
+        return batches;
+    }
+    /** POST one multipart batch to Tiden. Returns the upstream-shaped
+     *  `{data: {result: [{hash}]}}` envelope so callers stay unchanged
+     *  (Tiden's response body is `{status, result: [{hash, ...}]}`).
+     *
+     *  Hand-written on purpose: `POST /v1/products/{product}/attachments:upload`
+     *  is a multipart route that is NOT in the OpenAPI spec, so
+     *  The generated OpenAPI snapshot has no operation for it (the path appears
+     *  there only inside a doc comment on testRunServiceGetRunAttachment). It
+     *  still goes over the same axios instance as the reporter JSON calls, so
+     *  baseURL/auth/timeout stay shared; only the request building is local.
+     *  If the route is ever added to the spec, replace this with the generated
+     *  operation. */
+    async postAttachmentBatch(projectCode, data) {
+        const form = new form_data_1.default();
+        for (const item of data) {
+            form.append('file[]', item.value, {
+                filename: item.name,
+                ...(item.contentType ? { contentType: item.contentType } : {}),
+            });
+        }
+        const response = await this.http.post(`/v1/products/${projectCode}/attachments:upload`, form, { headers: form.getHeaders(), maxBodyLength: Infinity, maxContentLength: Infinity });
+        return { data: response.data };
+    }
+    async uploadWithRetry(projectCode, data, attachmentNames, maxRetries = 5, initialDelay = 1000) {
+        let lastError;
+        let delay = initialDelay;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await this.postAttachmentBatch(projectCode, data);
+            }
+            catch (error) {
+                lastError = error;
+                if ((0, is_axios_error_1.isAxiosError)(error)) {
+                    if (error.response?.status === 429) {
+                        if (attempt < maxRetries) {
+                            const retryAfter = this.getRetryAfter(error);
+                            const baseWaitTime = retryAfter ?? delay;
+                            const jitterPercent = 0.1 + Math.random() * 0.2;
+                            const jitter = baseWaitTime * jitterPercent;
+                            const waitTime = Math.floor(baseWaitTime + jitter);
+                            this.logger.logDebug(`Rate limit exceeded (429) for attachment(s) "${attachmentNames}". ` +
+                                `Retrying in ${waitTime}ms (attempt ${attempt + 1}/${maxRetries})`);
+                            await this.delay(waitTime);
+                            delay = Math.min(delay * 2, 30000);
+                        }
+                        else {
+                            this.logger.logError(`Failed to upload attachment(s) "${attachmentNames}" after ${maxRetries} retries due to rate limiting`);
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    getRetryAfter(error) {
+        const headers = error.response?.headers;
+        if (!headers)
+            return null;
+        const retryAfterHeader = headers['retry-after'];
+        if (retryAfterHeader && typeof retryAfterHeader === 'string') {
+            const retryAfterSeconds = parseInt(retryAfterHeader, 10);
+            if (!isNaN(retryAfterSeconds)) {
+                return retryAfterSeconds * 1000;
+            }
+        }
+        return null;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    ensureAttachmentSize(attachment) {
+        if (attachment.size > 0)
+            return;
+        try {
+            if (attachment.file_path) {
+                const stats = (0, fs_1.statSync)(attachment.file_path);
+                attachment.size = stats.size;
+            }
+            else if (attachment.content) {
+                if (typeof attachment.content === 'string') {
+                    if (looksLikeBase64(attachment.content)) {
+                        attachment.size = Buffer.from(attachment.content, 'base64').length;
+                    }
+                    else {
+                        attachment.size = Buffer.byteLength(attachment.content, 'utf8');
+                    }
+                }
+                else if (Buffer.isBuffer(attachment.content)) {
+                    attachment.size = attachment.content.length;
+                }
+                else {
+                    attachment.size = Buffer.byteLength(String(attachment.content), 'utf8');
+                }
+            }
+        }
+        catch (error) {
+            this.logger.logDebug(`Could not determine size for attachment "${attachment.file_path ?? attachment.file_name}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+            attachment.size = 0;
+        }
+    }
+    prepareAttachmentData(attachment) {
+        const contentType = typeof attachment.mime_type === 'string' && attachment.mime_type.length > 0
+            ? attachment.mime_type
+            : undefined;
+        if (attachment.file_path) {
+            return {
+                name: attachment.file_name,
+                value: (0, fs_1.createReadStream)(attachment.file_path),
+                ...(contentType ? { contentType } : {}),
+            };
+        }
+        return {
+            name: attachment.file_name,
+            value: typeof attachment.content === 'string'
+                ? Buffer.from(attachment.content, looksLikeBase64(attachment.content) ? 'base64' : 'utf8')
+                : attachment.content,
+            ...(contentType ? { contentType } : {}),
+        };
+    }
+}
+exports.AttachmentService = AttachmentService;

package/dist/client/services/result-transformer.d.ts

@@ -0,0 +1,21 @@
+import { ResultCreate } from '../reporter-api-models';
+import { Attachment, TestResultType } from '../../models';
+import { LoggerInterface } from '../../utils/logger';
+export declare class ResultTransformer {
+    private readonly logger;
+    private readonly rootSuite;
+    constructor(logger: LoggerInterface, rootSuite: string | undefined);
+    transform(result: TestResultType, attachmentUploader: (attachment: Attachment) => Promise<string>): Promise<ResultCreate>;
+    transformWithDefect(result: TestResultType, attachmentUploader: (attachment: Attachment) => Promise<string>, defect: boolean): Promise<ResultCreate>;
+    private uploadAttachments;
+    private transformSteps;
+    private transformStep;
+    private createBaseResultStep;
+    private processTextStep;
+    private processGherkinStep;
+    private processRequestStep;
+    private getExecution;
+    private transformParams;
+    private transformGroupParams;
+    private getSuitePath;
+}

package/dist/client/services/result-transformer.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultTransformer = void 0;
+const models_1 = require("../../models");
+const chalk_1 = __importDefault(require("chalk"));
+const statusMap = {
+    [models_1.TestStatusEnum.passed]: 'passed',
+    [models_1.TestStatusEnum.failed]: 'failed',
+    [models_1.TestStatusEnum.skipped]: 'skipped',
+    [models_1.TestStatusEnum.disabled]: 'skipped',
+    [models_1.TestStatusEnum.blocked]: 'blocked',
+    [models_1.TestStatusEnum.invalid]: 'invalid',
+};
+const stepStatusMap = {
+    [models_1.StepStatusEnum.passed]: 'passed',
+    [models_1.StepStatusEnum.failed]: 'failed',
+    [models_1.StepStatusEnum.blocked]: 'blocked',
+    [models_1.StepStatusEnum.skipped]: 'skipped',
+};
+class ResultTransformer {
+    logger;
+    rootSuite;
+    constructor(logger, rootSuite) {
+        this.logger = logger;
+        this.rootSuite = rootSuite;
+    }
+    async transform(result, attachmentUploader) {
+        const attachments = await this.uploadAttachments(result.attachments, attachmentUploader);
+        if (result.preparedAttachments) {
+            attachments.push(...result.preparedAttachments);
+        }
+        const steps = await this.transformSteps(result.steps, result.title, attachmentUploader);
+        const params = this.transformParams(result.params);
+        const groupParams = this.transformGroupParams(result.group_params, params);
+        // No linked case ids → omit the field (previously an explicit null; both
+        // decode to an empty repeated field server-side).
+        const caseIds = Array.isArray(result.case_id)
+            ? (result.case_id.length > 0 ? result.case_id : null)
+            : result.case_id !== null ? [result.case_id] : null;
+        // Field names/types follow the generated `ResultCreate` contract and are
+        // checked against it at test time: JSON is lowerCamelCase and int64s are
+        // strings. Nullable internal values are
+        // omitted rather than sent as `null` — protojson maps both to the field's
+        // zero value, and omitting keeps the generated optional types honest.
+        const model = {
+            id: result.id,
+            title: result.title,
+            execution: this.getExecution(result.execution),
+            ...(caseIds ? { testopsIds: caseIds } : {}),
+            attachments: attachments,
+            steps: steps,
+            params: params,
+            paramGroups: groupParams,
+            suitePath: this.getSuitePath(result.relations),
+            ...(result.message != null ? { message: result.message } : {}),
+            fields: result.fields,
+            defect: false,
+            ...(result.signature != null ? { signature: result.signature } : {}),
+        };
+        if (result.tags && result.tags.length > 0) {
+            model.fields = {
+                ...model.fields,
+                tags: [...new Set(result.tags)].join(','),
+            };
+        }
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(model)}`);
+        return model;
+    }
+    async transformWithDefect(result, attachmentUploader, defect) {
+        const model = await this.transform(result, attachmentUploader);
+        model.defect = defect;
+        return model;
+    }
+    async uploadAttachments(attachments, uploader) {
+        const hashes = [];
+        for (const attachment of attachments) {
+            const hash = await uploader(attachment);
+            if (hash)
+                hashes.push(hash);
+        }
+        return hashes;
+    }
+    async transformSteps(steps, testTitle, attachmentUploader) {
+        return Promise.all(steps.map(step => this.transformStep(step, testTitle, attachmentUploader)));
+    }
+    async transformStep(step, testTitle, attachmentUploader) {
+        const attachmentHashes = await this.uploadAttachments(step.attachments, attachmentUploader);
+        const resultStep = this.createBaseResultStep(attachmentHashes, step.execution.status);
+        if (step.step_type === models_1.StepType.TEXT) {
+            this.processTextStep(step, resultStep, testTitle);
+        }
+        else if (step.step_type === models_1.StepType.GHERKIN) {
+            this.processGherkinStep(step, resultStep);
+        }
+        else if (step.step_type === models_1.StepType.REQUEST) {
+            this.processRequestStep(step, resultStep);
+        }
+        if (step.steps.length > 0) {
+            resultStep.steps = await this.transformSteps(step.steps, testTitle, attachmentUploader);
+        }
+        return resultStep;
+    }
+    createBaseResultStep(attachmentHashes, status) {
+        return {
+            data: { action: '' },
+            execution: {
+                status: stepStatusMap[status],
+                attachments: attachmentHashes,
+            },
+        };
+    }
+    processTextStep(step, resultStep, testTitle) {
+        if (!('action' in step.data) || !resultStep.data)
+            return;
+        const stepData = step.data;
+        resultStep.data.action = stepData.action || 'Unnamed step';
+        if (stepData.action === '') {
+            this.logger.log((0, chalk_1.default) `{magenta Test '${testTitle}' has empty action in step. The reporter will mark this step as unnamed step.}`);
+        }
+        if (stepData.expected_result != null) {
+            resultStep.data.expectedResult = stepData.expected_result;
+        }
+        if (stepData.data != null) {
+            resultStep.data.inputData = stepData.data;
+        }
+    }
+    processGherkinStep(step, resultStep) {
+        if (!('keyword' in step.data) || !resultStep.data)
+            return;
+        resultStep.data.action = step.data.keyword;
+    }
+    processRequestStep(step, resultStep) {
+        if (!('request_method' in step.data) || !resultStep.data)
+            return;
+        const stepData = step.data;
+        resultStep.data.action = `${stepData.request_method} ${stepData.request_url}`;
+    }
+    getExecution(exec) {
+        // `duration` is an int64 in the proto, so the generated type carries it as
+        // a string (protojson's int64 convention); the timestamps stay numbers
+        // (Unix seconds, fractional ms).
+        return {
+            status: statusMap[exec.status],
+            ...(exec.start_time != null ? { startTime: exec.start_time } : {}),
+            ...(exec.end_time != null ? { endTime: exec.end_time } : {}),
+            ...(exec.duration != null ? { duration: String(exec.duration) } : {}),
+            ...(exec.stacktrace != null ? { stacktrace: exec.stacktrace } : {}),
+            ...(exec.thread != null ? { thread: exec.thread } : {}),
+        };
+    }
+    transformParams(params) {
+        const transformedParams = {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value != null) {
+                transformedParams[key] = String(value);
+            }
+        }
+        return transformedParams;
+    }
+    transformGroupParams(groupParams, params) {
+        const keys = Object.keys(groupParams);
+        if (keys.length === 0)
+            return [];
+        for (const [key, value] of Object.entries(groupParams)) {
+            if (value) {
+                params[key] = value;
+            }
+        }
+        return [{ names: keys }];
+    }
+    getSuitePath(relation) {
+        const titles = relation?.suite?.data.map(d => d.title) ?? [];
+        const path = this.rootSuite ? [this.rootSuite, ...titles] : titles;
+        return path.map(title => ({ title }));
+    }
+}
+exports.ResultTransformer = ResultTransformer;

package/dist/client/services/run-service.d.ts

@@ -0,0 +1,20 @@
+import { ReporterApi } from '../reporter-api';
+import { LoggerInterface } from '../../utils/logger';
+import { TidenOptionsType } from '../../models/config/TidenOptionsType';
+export declare class RunService {
+    private readonly logger;
+    private readonly api;
+    constructor(logger: LoggerInterface, api: ReporterApi);
+    /**
+     * Creates a Tiden run and returns its per-product seq number (int32).
+     * `environment` is a slug: the server resolves it and auto-creates
+     * unknown slugs. An empty title gets the server-side default.
+     */
+    createRun(config: TidenOptionsType, environment?: string): Promise<number>;
+    /**
+     * Completes the run. Server-idempotent for already-completed runs, so the
+     * upstream pre-flight GET is gone. Completes by default; only skips when
+     * run.complete is explicitly false (sharded CI: the orchestrator owns completion).
+     */
+    completeRun(runId: number, config: TidenOptionsType): Promise<void>;
+}

package/dist/client/services/run-service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunService = void 0;
+const tiden_error_1 = require("../../utils/tiden-error");
+const api_error_handler_1 = require("./api-error-handler");
+class RunService {
+    logger;
+    api;
+    constructor(logger, api) {
+        this.logger = logger;
+        this.api = api;
+    }
+    /**
+     * Creates a Tiden run and returns its per-product seq number (int32).
+     * `environment` is a slug: the server resolves it and auto-creates
+     * unknown slugs. An empty title gets the server-side default.
+     */
+    async createRun(config, environment) {
+        if (config.run.id) {
+            return config.run.id; // sharded CI: pre-created run
+        }
+        try {
+            // Body shape follows the OpenAPI contract (lowerCamelCase JSON, hence
+            // `clientMeta`) and is checked against its generated model in tests.
+            const body = {
+                title: config.run.title ?? '',
+                description: config.run.description ?? '',
+                environment: environment ?? '',
+                branch: config.run.branch ?? '',
+                configurations: config.configurations
+                    ? Object.fromEntries(config.configurations.values.map((v) => [v.name, v.value]))
+                    : {},
+                clientMeta: config.clientMeta ?? {},
+            };
+            this.logger.logDebug(`Creating test run: ${JSON.stringify(body)}`);
+            const { data } = await this.api.createTestRun(config.product, body);
+            const seqNum = data.run?.seqNum;
+            if (!seqNum) {
+                throw new tiden_error_1.TidenError('Failed to create test run');
+            }
+            this.logger.logDebug(`Run create response: seqNum=${seqNum}`);
+            return seqNum;
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error creating test run');
+        }
+    }
+    /**
+     * Completes the run. Server-idempotent for already-completed runs, so the
+     * upstream pre-flight GET is gone. Completes by default; only skips when
+     * run.complete is explicitly false (sharded CI: the orchestrator owns completion).
+     */
+    async completeRun(runId, config) {
+        // Complete by default; only an explicit `complete: false` (sharded CI:
+        // the orchestrator owns completion) skips it.
+        if (config.run.complete === false) {
+            return;
+        }
+        try {
+            await this.api.completeTestRun(config.product, runId);
+            this.logger.log(`Test run #${runId} completed`);
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error on completing run');
+        }
+    }
+}
+exports.RunService = RunService;

package/dist/client/tiden-client.d.ts

@@ -0,0 +1,34 @@
+import { IClient } from './interface';
+import { LoggerInterface } from '../utils/logger';
+import { TidenOptionsType } from '../models/config/TidenOptionsType';
+import { Attachment, TestResultType } from '../models';
+/**
+ * Facade over the Tiden REST API.
+ *
+ * The JSON endpoints (create/report/complete) go through the narrow reporter
+ * API. Its types are checked against the generated OpenAPI snapshot at test
+ * time without making that full client a runtime dependency. Attachment
+ * upload stays hand-written because it is multipart. Both share one axios
+ * instance.
+ */
+export declare class TidenApiClient implements IClient {
+    private readonly logger;
+    private readonly config;
+    private readonly environment;
+    private readonly http;
+    private readonly api;
+    private readonly runService;
+    private readonly attachmentService;
+    private readonly resultTransformer;
+    constructor(logger: LoggerInterface, config: TidenOptionsType, environment: string | undefined, rootSuite: string | undefined);
+    createRun(): Promise<number>;
+    completeRun(runId: number): Promise<void>;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    /** Public run report links have no Tiden equivalent in v1. */
+    enablePublicReport(_runId: number): Promise<void>;
+    uploadResults(runId: number, results: TestResultType[]): Promise<void>;
+    /** 429-only retry (Retry-After honored, exp backoff, 30s cap); 400 is
+     *  terminal — resending an identical batch fails identically, so log
+     *  every per-entry ReportError from details[] and re-throw. */
+    private postResultsWithRetry;
+}