qase-javascript-commons 2.6.3 → 2.6.4

package/dist/client/clientV2.js

@@ -1,277 +1,30 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientV2 = void 0;
-const chalk_1 = __importDefault(require("chalk"));
 const qase_api_v2_client_1 = require("qase-api-v2-client");
-const models_1 = require("../models");
 const clientV1_1 = require("./clientV1");
-const form_data_1 = __importDefault(require("form-data"));
-const API_CONFIG = {
-    DEFAULT_HOST: 'qase.io',
-    BASE_URL: 'https://api-',
-    VERSION: '/v2'
-};
+const api_config_builder_1 = require("./transport/api-config-builder");
+const result_transformer_1 = require("./services/result-transformer");
+const api_error_handler_1 = require("./services/api-error-handler");
 class ClientV2 extends clientV1_1.ClientV1 {
-    rootSuite;
-    static 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',
-    };
-    static stepStatusMap = {
-        [models_1.StepStatusEnum.passed]: qase_api_v2_client_1.ResultStepStatus.PASSED,
-        [models_1.StepStatusEnum.failed]: qase_api_v2_client_1.ResultStepStatus.FAILED,
-        [models_1.StepStatusEnum.blocked]: qase_api_v2_client_1.ResultStepStatus.BLOCKED,
-        [models_1.StepStatusEnum.skipped]: qase_api_v2_client_1.ResultStepStatus.SKIPPED,
-    };
     resultsClient;
+    resultTransformer;
     constructor(logger, config, environment, rootSuite, hostData, reporterName, frameworkName) {
         super(logger, config, environment);
-        this.rootSuite = rootSuite;
-        const apiConfig = this.createApiConfigV2(hostData, reporterName, frameworkName);
+        const apiConfig = (0, api_config_builder_1.createApiConfigV2)(config, hostData, reporterName, frameworkName);
         this.resultsClient = new qase_api_v2_client_1.ResultsApi(apiConfig);
-    }
-    createApiConfigV2(hostData, reporterName, frameworkName) {
-        const apiConfig = new qase_api_v2_client_1.Configuration({ apiKey: this.config.api.token, formDataCtor: form_data_1.default });
-        apiConfig.basePath = this.config.api.host && this.config.api.host != API_CONFIG.DEFAULT_HOST
-            ? `${API_CONFIG.BASE_URL}${this.config.api.host}${API_CONFIG.VERSION}`
-            : `https://api.${API_CONFIG.DEFAULT_HOST}${API_CONFIG.VERSION}`;
-        // Set default headers for all requests
-        if (hostData) {
-            const headers = this.buildHeaders(hostData, reporterName, frameworkName);
-            const existingHeaders = apiConfig.baseOptions?.headers || {};
-            const baseOptionsWithHeaders = {
-                ...(apiConfig.baseOptions || {}),
-                headers: {
-                    ...existingHeaders,
-                    ...headers,
-                },
-            };
-            apiConfig.baseOptions = baseOptionsWithHeaders;
-        }
-        return apiConfig;
-    }
-    buildHeaders(hostData, reporterName, frameworkName) {
-        const headers = {};
-        // Build X-Client header
-        const clientParts = [];
-        if (reporterName && reporterName.trim()) {
-            clientParts.push(`reporter=${reporterName}`);
-        }
-        if (hostData.reporter && hostData.reporter.trim()) {
-            clientParts.push(`reporter_version=${hostData.reporter}`);
-        }
-        if (frameworkName && frameworkName.trim()) {
-            clientParts.push(`framework=${frameworkName}`);
-        }
-        if (hostData.framework && hostData.framework.trim()) {
-            clientParts.push(`framework_version=${hostData.framework}`);
-        }
-        if (hostData.apiClientV1 && hostData.apiClientV1.trim()) {
-            clientParts.push(`client_version_v1=${hostData.apiClientV1}`);
-        }
-        if (hostData.apiClientV2 && hostData.apiClientV2.trim()) {
-            clientParts.push(`client_version_v2=${hostData.apiClientV2}`);
-        }
-        if (hostData.commons && hostData.commons.trim()) {
-            clientParts.push(`core_version=${hostData.commons}`);
-        }
-        if (clientParts.length > 0) {
-            headers['X-Client'] = clientParts.join(';');
-        }
-        // Build X-Platform header
-        const platformParts = [];
-        if (hostData.system && hostData.system.trim()) {
-            platformParts.push(`os=${hostData.system}`);
-        }
-        if (hostData.arch && hostData.arch.trim()) {
-            platformParts.push(`arch=${hostData.arch}`);
-        }
-        if (hostData.language && hostData.language.trim()) {
-            platformParts.push(`node=${hostData.language}`);
-        }
-        if (hostData.packageManager && hostData.packageManager.trim()) {
-            platformParts.push(`npm=${hostData.packageManager}`);
-        }
-        if (platformParts.length > 0) {
-            headers['X-Platform'] = platformParts.join(';');
-        }
-        return headers;
+        this.resultTransformer = new result_transformer_1.ResultTransformer(logger, rootSuite);
     }
     async uploadResults(runId, results) {
         try {
-            const models = await Promise.all(results.map(result => this.transformTestResult(result)));
+            const models = await Promise.all(results.map(result => this.resultTransformer.transformWithDefect(result, (a) => this.attachmentService.uploadAttachments(this.config.project, [a], this.config.uploadAttachments ?? true).then(hashes => hashes[0] ?? ''), this.config.defect ?? false)));
             await this.resultsClient.createResultsV2(this.config.project, runId, {
                 results: models,
             });
         }
         catch (error) {
-            throw this.processError(error, 'Error on uploading results', results);
-        }
-    }
-    async transformTestResult(result) {
-        const attachments = await this.uploadAttachments(result.attachments);
-        if (result.preparedAttachments) {
-            attachments.push(...result.preparedAttachments);
-        }
-        const steps = await this.transformSteps(result.steps, result.title);
-        const params = this.transformParams(result.params);
-        const groupParams = this.transformGroupParams(result.group_params, params);
-        const relations = this.getRelation(result.relations);
-        const model = {
-            title: result.title,
-            execution: this.getExecution(result.execution),
-            testops_ids: Array.isArray(result.testops_id)
-                ? result.testops_id
-                : result.testops_id !== null ? [result.testops_id] : null,
-            attachments: attachments,
-            steps: steps,
-            params: params,
-            param_groups: groupParams,
-            relations: relations,
-            message: result.message,
-            fields: result.fields,
-            defect: this.config.defect ?? false,
-            signature: result.signature,
-        };
-        if (result.tags.length > 0) {
-            model.fields = {
-                ...model.fields,
-                tags: [...new Set(result.tags)].join(','),
-            };
-        }
-        this.logger.logDebug(`Transformed result: ${JSON.stringify(model)}`);
-        return model;
-    }
-    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 [keys];
-    }
-    async transformSteps(steps, testTitle) {
-        return Promise.all(steps.map(step => this.transformStep(step, testTitle)));
-    }
-    async transformStep(step, testTitle) {
-        const attachmentHashes = await this.uploadAttachments(step.attachments);
-        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);
-        }
-        return resultStep;
-    }
-    createBaseResultStep(attachmentHashes, status) {
-        return {
-            data: {
-                action: '',
-            },
-            execution: {
-                status: ClientV2.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.expected_result = stepData.expected_result;
-        }
-        if (stepData.data != null) {
-            resultStep.data.input_data = stepData.data;
-        }
-    }
-    processGherkinStep(step, resultStep) {
-        if (!('keyword' in step.data) || !resultStep.data) {
-            return;
-        }
-        const stepData = step.data;
-        resultStep.data.action = stepData.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) {
-        return {
-            status: ClientV2.statusMap[exec.status],
-            start_time: exec.start_time,
-            end_time: exec.end_time,
-            duration: exec.duration,
-            stacktrace: exec.stacktrace,
-            thread: exec.thread,
-        };
-    }
-    getRelation(relation) {
-        if (!relation?.suite) {
-            return this.getDefaultSuiteRelation();
-        }
-        const suiteData = this.buildSuiteData(relation.suite.data);
-        return { suite: { data: suiteData } };
-    }
-    getDefaultSuiteRelation() {
-        if (!this.rootSuite)
-            return {};
-        return {
-            suite: {
-                data: [{
-                        public_id: null,
-                        title: this.rootSuite,
-                    }],
-            },
-        };
-    }
-    buildSuiteData(suiteData) {
-        const result = [];
-        if (this.rootSuite) {
-            result.push({
-                public_id: null,
-                title: this.rootSuite,
-            });
+            throw (0, api_error_handler_1.processError)(error, 'Error on uploading results', results);
         }
-        return result.concat(suiteData.map(data => ({
-            public_id: null,
-            title: data.title,
-        })));
     }
 }
 exports.ClientV2 = ClientV2;

package/dist/client/services/api-error-handler.d.ts

@@ -0,0 +1,10 @@
+import { QaseError } from '../../utils/qase-error';
+export declare enum ApiErrorCode {
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    BAD_REQUEST = 400,
+    UNPROCESSABLE_ENTITY = 422
+}
+export declare function processError(error: unknown, message: string, model?: object): QaseError;
+export declare function getErrorMessage(error: unknown): string;

package/dist/client/services/api-error-handler.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiErrorCode = void 0;
+exports.processError = processError;
+exports.getErrorMessage = getErrorMessage;
+const is_axios_error_1 = require("../../utils/is-axios-error");
+const qase_error_1 = require("../../utils/qase-error");
+var ApiErrorCode;
+(function (ApiErrorCode) {
+    ApiErrorCode[ApiErrorCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    ApiErrorCode[ApiErrorCode["FORBIDDEN"] = 403] = "FORBIDDEN";
+    ApiErrorCode[ApiErrorCode["NOT_FOUND"] = 404] = "NOT_FOUND";
+    ApiErrorCode[ApiErrorCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    ApiErrorCode[ApiErrorCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+})(ApiErrorCode || (exports.ApiErrorCode = ApiErrorCode = {}));
+function processError(error, message, model) {
+    if (!(0, is_axios_error_1.isAxiosError)(error)) {
+        return new qase_error_1.QaseError(message, { cause: error });
+    }
+    const err = error;
+    const errorData = err.response?.data;
+    const status = err.response?.status;
+    switch (status) {
+        case ApiErrorCode.UNAUTHORIZED:
+            return new qase_error_1.QaseError(`${message}: Unauthorized. Please check your API token.`);
+        case ApiErrorCode.FORBIDDEN:
+            return new qase_error_1.QaseError(`${message}: ${errorData?.errorMessage ?? 'Forbidden'}`);
+        case ApiErrorCode.NOT_FOUND:
+            return new qase_error_1.QaseError(`${message}: Not found.`);
+        case ApiErrorCode.BAD_REQUEST:
+        case ApiErrorCode.UNPROCESSABLE_ENTITY:
+            return new qase_error_1.QaseError(`${message}: Bad request\n${JSON.stringify(errorData)}\nBody: ${JSON.stringify(model)}`);
+        default:
+            return new qase_error_1.QaseError(message, { cause: err });
+    }
+}
+function getErrorMessage(error) {
+    if ((0, is_axios_error_1.isAxiosError)(error)) {
+        const err = error;
+        const errorData = err.response?.data;
+        return errorData?.errorMessage ?? errorData?.error ?? errorData?.message ?? 'Unknown API error';
+    }
+    return error instanceof Error ? error.message : 'Unknown error';
+}

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

@@ -0,0 +1,16 @@
+import { AttachmentsApi } from 'qase-api-client';
+import { Attachment } from '../../models';
+import { LoggerInterface } from '../../utils/logger';
+export declare class AttachmentService {
+    private readonly logger;
+    private readonly attachmentClient;
+    constructor(logger: LoggerInterface, attachmentClient: AttachmentsApi);
+    uploadAttachment(projectCode: string, attachment: Attachment): Promise<string>;
+    uploadAttachments(projectCode: string, attachments: Attachment[], uploadEnabled: boolean): Promise<string[]>;
+    private groupIntoBatches;
+    private uploadWithRetry;
+    private getRetryAfter;
+    private delay;
+    private ensureAttachmentSize;
+    private prepareAttachmentData;
+}

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

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentService = void 0;
+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
+class AttachmentService {
+    logger;
+    attachmentClient;
+    constructor(logger, attachmentClient) {
+        this.logger = logger;
+        this.attachmentClient = attachmentClient;
+    }
+    async uploadAttachment(projectCode, attachment) {
+        try {
+            const data = this.prepareAttachmentData(attachment);
+            const response = await this.attachmentClient.uploadAttachment(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;
+    }
+    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.attachmentClient.uploadAttachment(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 (attachment.content.match(/^[A-Za-z0-9+/=]+$/)) {
+                        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) {
+        if (attachment.file_path) {
+            return {
+                name: attachment.file_name,
+                value: (0, fs_1.createReadStream)(attachment.file_path),
+            };
+        }
+        return {
+            name: attachment.file_name,
+            value: typeof attachment.content === 'string'
+                ? Buffer.from(attachment.content, attachment.content.match(/^[A-Za-z0-9+/=]+$/) ? 'base64' : undefined)
+                : attachment.content,
+        };
+    }
+}
+exports.AttachmentService = AttachmentService;

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

@@ -0,0 +1,12 @@
+import { ConfigurationsApi } from 'qase-api-client';
+import { TestOpsConfigurationType } from '../../models/config/TestOpsOptionsType';
+import { LoggerInterface } from '../../utils/logger';
+export declare class ConfigurationService {
+    private readonly logger;
+    private readonly configurationClient;
+    constructor(logger: LoggerInterface, configurationClient: ConfigurationsApi);
+    handleConfigurations(projectCode: string, configurations: TestOpsConfigurationType): Promise<number[]>;
+    private getConfigurations;
+    private createConfigurationGroup;
+    private createConfiguration;
+}