qase-javascript-commons 2.6.3 → 2.6.4

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationService = void 0;
+const api_error_handler_1 = require("./api-error-handler");
+class ConfigurationService {
+    logger;
+    configurationClient;
+    constructor(logger, configurationClient) {
+        this.logger = logger;
+        this.configurationClient = configurationClient;
+    }
+    async handleConfigurations(projectCode, configurations) {
+        if (!configurations.values.length) {
+            return [];
+        }
+        const configurationIds = [];
+        try {
+            const existingGroups = await this.getConfigurations(projectCode);
+            for (const configValue of configurations.values) {
+                const { name: groupName, value: configName } = configValue;
+                const group = existingGroups.find(g => g.title === groupName);
+                let groupId;
+                if (group) {
+                    groupId = group.id;
+                    this.logger.logDebug(`Found existing configuration group: ${groupName}`);
+                }
+                else {
+                    if (configurations.createIfNotExists) {
+                        const newGroupId = await this.createConfigurationGroup(projectCode, groupName);
+                        if (newGroupId) {
+                            groupId = newGroupId;
+                            this.logger.logDebug(`Created new configuration group: ${groupName} with ID: ${groupId}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Failed to create configuration group: ${groupName}, skipping`);
+                            continue;
+                        }
+                    }
+                    else {
+                        this.logger.logDebug(`Configuration group not found: ${groupName}, skipping`);
+                        continue;
+                    }
+                }
+                if (groupId) {
+                    const existingConfig = group?.configurations.find(c => c.title === configName);
+                    if (!existingConfig) {
+                        if (configurations.createIfNotExists) {
+                            const configId = await this.createConfiguration(projectCode, configName, groupId);
+                            if (configId) {
+                                configurationIds.push(configId);
+                            }
+                            this.logger.logDebug(`Created configuration: ${configName} in group: ${groupName}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Configuration not found: ${configName} in group: ${groupName}, skipping`);
+                        }
+                    }
+                    else {
+                        if (existingConfig.id) {
+                            configurationIds.push(existingConfig.id);
+                        }
+                        this.logger.logDebug(`Configuration already exists: ${configName} in group: ${groupName}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.logError('Error handling configurations:', error);
+        }
+        return configurationIds;
+    }
+    async getConfigurations(projectCode) {
+        try {
+            const { data } = await this.configurationClient.getConfigurations(projectCode);
+            const entities = data.result?.entities ?? [];
+            return entities.map(group => ({
+                id: group.id ?? 0,
+                title: group.title ?? '',
+                configurations: group.configurations?.map(config => ({
+                    id: config.id ?? 0,
+                    title: config.title ?? '',
+                })) ?? [],
+            }));
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error getting configurations');
+        }
+    }
+    async createConfigurationGroup(projectCode, title) {
+        try {
+            const group = { title };
+            const { data } = await this.configurationClient.createConfigurationGroup(projectCode, group);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error creating configuration group');
+        }
+    }
+    async createConfiguration(projectCode, title, groupId) {
+        try {
+            const config = { title, group_id: groupId };
+            const { data } = await this.configurationClient.createConfiguration(projectCode, config);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error creating configuration');
+        }
+    }
+}
+exports.ConfigurationService = ConfigurationService;

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

@@ -0,0 +1,23 @@
+import { ResultCreate } from 'qase-api-v2-client';
+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 getRelation;
+    private getDefaultSuiteRelation;
+    private buildSuiteData;
+}

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

@@ -0,0 +1,188 @@
+"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 qase_api_v2_client_1 = require("qase-api-v2-client");
+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]: 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,
+};
+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);
+        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: 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;
+    }
+    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.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;
+        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) {
+        return {
+            status: statusMap[exec.status],
+            start_time: exec.start_time,
+            end_time: exec.end_time,
+            duration: exec.duration,
+            stacktrace: exec.stacktrace,
+            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 [keys];
+    }
+    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 });
+        }
+        return result.concat(suiteData.map(data => ({ public_id: null, title: data.title })));
+    }
+}
+exports.ResultTransformer = ResultTransformer;

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

@@ -0,0 +1,17 @@
+import { RunsApi, EnvironmentsApi } from 'qase-api-client';
+import { TestOpsOptionsType } from '../../models/config/TestOpsOptionsType';
+import { LoggerInterface } from '../../utils/logger';
+import { ConfigurationService } from './configuration-service';
+export declare class RunService {
+    private readonly logger;
+    private readonly runClient;
+    private readonly environmentClient;
+    private readonly configurationService;
+    private readonly appUrl;
+    constructor(logger: LoggerInterface, runClient: RunsApi, environmentClient: EnvironmentsApi, configurationService: ConfigurationService, appUrl: string | undefined);
+    createRun(config: TestOpsOptionsType, environment?: string): Promise<number>;
+    completeRun(runId: number, config: TestOpsOptionsType): Promise<void>;
+    enablePublicReport(projectCode: string, runId: number): Promise<void>;
+    private getEnvironmentId;
+    private prepareRunObject;
+}

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

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunService = void 0;
+const qase_api_client_1 = require("qase-api-client");
+const qase_error_1 = require("../../utils/qase-error");
+const dateUtils_1 = require("../dateUtils");
+const api_error_handler_1 = require("./api-error-handler");
+const chalk_1 = __importDefault(require("chalk"));
+class RunService {
+    logger;
+    runClient;
+    environmentClient;
+    configurationService;
+    appUrl;
+    constructor(logger, runClient, environmentClient, configurationService, appUrl) {
+        this.logger = logger;
+        this.runClient = runClient;
+        this.environmentClient = environmentClient;
+        this.configurationService = configurationService;
+        this.appUrl = appUrl;
+    }
+    async createRun(config, environment) {
+        if (config.run.id) {
+            return config.run.id;
+        }
+        try {
+            let configurationIds = [];
+            if (config.configurations) {
+                configurationIds = await this.configurationService.handleConfigurations(config.project, config.configurations);
+            }
+            const environmentId = await this.getEnvironmentId(config.project, environment);
+            const runObject = this.prepareRunObject(config, environmentId, configurationIds);
+            this.logger.logDebug(`Creating test run: ${JSON.stringify(runObject)}`);
+            const { data } = await this.runClient.createRun(config.project, runObject);
+            if (!data.result?.id) {
+                throw new qase_error_1.QaseError('Failed to create test run');
+            }
+            this.logger.logDebug(`Test run created: ${JSON.stringify(data)}`);
+            if (config.run.externalLink && data.result.id) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+                const apiType = config.run.externalLink.type === 'jiraCloud'
+                    ? qase_api_client_1.RunExternalIssuesTypeEnum.JIRA_CLOUD
+                    : qase_api_client_1.RunExternalIssuesTypeEnum.JIRA_SERVER;
+                await this.runClient.runUpdateExternalIssue(config.project, {
+                    type: apiType,
+                    links: [{
+                            run_id: data.result.id,
+                            external_issue: config.run.externalLink.link,
+                        }],
+                });
+            }
+            return data.result.id;
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error creating test run');
+        }
+    }
+    async completeRun(runId, config) {
+        if (!config.run.complete) {
+            return;
+        }
+        try {
+            await this.runClient.completeRun(config.project, runId);
+        }
+        catch (error) {
+            throw (0, api_error_handler_1.processError)(error, 'Error on completing run');
+        }
+        if (this.appUrl) {
+            const runUrl = `${this.appUrl}/run/${config.project}/dashboard/${runId}`;
+            this.logger.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
+        }
+    }
+    async enablePublicReport(projectCode, runId) {
+        try {
+            const { data } = await this.runClient.updateRunPublicity(projectCode, runId, { status: true });
+            if (data.result?.url) {
+                this.logger.log((0, chalk_1.default) `{blue Public report link: ${data.result.url}}`);
+            }
+        }
+        catch (error) {
+            this.logger.log((0, chalk_1.default) `{yellow Failed to generate public report link: ${(0, api_error_handler_1.getErrorMessage)(error)}}`);
+        }
+    }
+    async getEnvironmentId(projectCode, environment) {
+        if (!environment)
+            return undefined;
+        const { data } = await this.environmentClient.getEnvironments(projectCode, undefined, environment, 100);
+        return data.result?.entities?.find((env) => env.slug === environment)?.id;
+    }
+    prepareRunObject(config, environmentId, configurationIds) {
+        const runObject = {
+            title: config.run.title ?? `Automated run ${new Date().toISOString()}`,
+            description: config.run.description ?? '',
+            is_autotest: true,
+            cases: [],
+            start_time: (0, dateUtils_1.getStartTime)(),
+            tags: config.run.tags ?? [],
+        };
+        if (environmentId !== undefined) {
+            runObject.environment_id = environmentId;
+        }
+        if (config.plan.id) {
+            runObject.plan_id = config.plan.id;
+        }
+        if (configurationIds && configurationIds.length > 0) {
+            runObject.configurations = configurationIds;
+        }
+        return runObject;
+    }
+}
+exports.RunService = RunService;

package/dist/client/transport/api-config-builder.d.ts

@@ -0,0 +1,8 @@
+import { Configuration as ConfigurationV1 } from 'qase-api-client';
+import { Configuration as ConfigurationV2 } from 'qase-api-v2-client';
+import { TestOpsOptionsType } from '../../models/config/TestOpsOptionsType';
+import { HostData } from '../../models/host-data';
+export declare function resolveAppUrl(config: TestOpsOptionsType): string;
+export declare function createApiConfigV1(config: TestOpsOptionsType): ConfigurationV1;
+export declare function createApiConfigV2(config: TestOpsOptionsType, hostData?: HostData, reporterName?: string, frameworkName?: string): ConfigurationV2;
+export declare function buildHeaders(hostData: HostData, reporterName?: string, frameworkName?: string): Record<string, string>;

package/dist/client/transport/api-config-builder.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAppUrl = resolveAppUrl;
+exports.createApiConfigV1 = createApiConfigV1;
+exports.createApiConfigV2 = createApiConfigV2;
+exports.buildHeaders = buildHeaders;
+const qase_api_client_1 = require("qase-api-client");
+const qase_api_v2_client_1 = require("qase-api-v2-client");
+const form_data_1 = __importDefault(require("form-data"));
+const DEFAULT_API_HOST = 'qase.io';
+const API_BASE_URL = 'https://api-';
+const APP_BASE_URL = 'https://';
+const API_V1 = '/v1';
+const API_V2 = '/v2';
+function resolveBasePath(host, version) {
+    if (host && host !== DEFAULT_API_HOST) {
+        return `${API_BASE_URL}${host}${version}`;
+    }
+    return `https://api.${DEFAULT_API_HOST}${version}`;
+}
+function resolveAppUrl(config) {
+    if (config.api.host && config.api.host !== DEFAULT_API_HOST) {
+        return `${APP_BASE_URL}${config.api.host}`;
+    }
+    return `https://app.${DEFAULT_API_HOST}`;
+}
+function createApiConfigV1(config) {
+    const apiConfig = new qase_api_client_1.Configuration({ apiKey: config.api.token, formDataCtor: form_data_1.default });
+    apiConfig.basePath = resolveBasePath(config.api.host, API_V1);
+    return apiConfig;
+}
+function createApiConfigV2(config, hostData, reporterName, frameworkName) {
+    const apiConfig = new qase_api_v2_client_1.Configuration({ apiKey: config.api.token, formDataCtor: form_data_1.default });
+    apiConfig.basePath = resolveBasePath(config.api.host, API_V2);
+    if (hostData) {
+        const headers = buildHeaders(hostData, reporterName, frameworkName);
+        const existingHeaders = apiConfig.baseOptions?.headers ?? {};
+        const baseOptionsWithHeaders = {
+            ...(apiConfig.baseOptions ?? {}),
+            headers: {
+                ...existingHeaders,
+                ...headers,
+            },
+        };
+        apiConfig.baseOptions = baseOptionsWithHeaders;
+    }
+    return apiConfig;
+}
+function buildHeaders(hostData, reporterName, frameworkName) {
+    const headers = {};
+    const clientParts = [];
+    if (reporterName?.trim()) {
+        clientParts.push(`reporter=${reporterName}`);
+    }
+    if (hostData.reporter?.trim()) {
+        clientParts.push(`reporter_version=${hostData.reporter}`);
+    }
+    if (frameworkName?.trim()) {
+        clientParts.push(`framework=${frameworkName}`);
+    }
+    if (hostData.framework?.trim()) {
+        clientParts.push(`framework_version=${hostData.framework}`);
+    }
+    if (hostData.apiClientV1?.trim()) {
+        clientParts.push(`client_version_v1=${hostData.apiClientV1}`);
+    }
+    if (hostData.apiClientV2?.trim()) {
+        clientParts.push(`client_version_v2=${hostData.apiClientV2}`);
+    }
+    if (hostData.commons?.trim()) {
+        clientParts.push(`core_version=${hostData.commons}`);
+    }
+    if (clientParts.length > 0) {
+        headers['X-Client'] = clientParts.join(';');
+    }
+    const platformParts = [];
+    if (hostData.system?.trim()) {
+        platformParts.push(`os=${hostData.system}`);
+    }
+    if (hostData.arch?.trim()) {
+        platformParts.push(`arch=${hostData.arch}`);
+    }
+    if (hostData.language?.trim()) {
+        platformParts.push(`node=${hostData.language}`);
+    }
+    if (hostData.packageManager?.trim()) {
+        platformParts.push(`npm=${hostData.packageManager}`);
+    }
+    if (platformParts.length > 0) {
+        headers['X-Platform'] = platformParts.join(';');
+    }
+    return headers;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.6.3",
+  "version": "2.6.4",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",