qase-javascript-commons 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/reporters/report-reporter.d.ts

@@ -0,0 +1,46 @@
+import { AbstractReporter } from './abstract-reporter';
+import { WriterInterface } from '../writer';
+import { LoggerInterface } from '../utils/logger';
+/**
+ * @class ReportReporter
+ * @extends AbstractReporter
+ */
+export declare class ReportReporter extends AbstractReporter {
+    private writer;
+    private readonly environment;
+    private readonly runId;
+    private startTime;
+    /**
+     * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
+     * @param {string | undefined} environment
+     * @param {number | undefined} runId
+     */
+    constructor(logger: LoggerInterface, writer: WriterInterface, environment?: string, runId?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     *
+     */
+    publish(): Promise<void>;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    private copyStepAttachments;
+    /**
+     * @returns {HostData}
+     */
+    private getHostInfo;
+    /**
+     * @returns {string}
+     */
+    private getComputerName;
+    /**
+     * @returns {string}
+     */
+    private getDetailedOSInfo;
+}

package/dist/reporters/report-reporter.js

@@ -0,0 +1,185 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportReporter = void 0;
+const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const os = __importStar(require("os"));
+const cp = __importStar(require("child_process"));
+const process = __importStar(require("process"));
+/**
+ * @class ReportReporter
+ * @extends AbstractReporter
+ */
+class ReportReporter extends abstract_reporter_1.AbstractReporter {
+    /**
+     * @param {LoggerInterface} logger
+     * @param {WriterInterface} writer
+     * @param {string | undefined} environment
+     * @param {number | undefined} runId
+     */
+    constructor(logger, writer, environment, runId) {
+        super(logger);
+        this.writer = writer;
+        this.startTime = Date.now();
+        this.environment = environment;
+        this.runId = runId;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async startTestRun() {
+        this.startTime = Date.now();
+    }
+    /**
+     * @returns {Promise<void>}
+     *
+     */
+    async publish() {
+        this.writer.clearPreviousResults();
+        const report = {
+            title: 'Test report',
+            execution: {
+                start_time: this.startTime,
+                end_time: Date.now(),
+                duration: Date.now() - this.startTime,
+                cumulative_duration: 0,
+            },
+            stats: {
+                total: 0,
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                broken: 0,
+                muted: 0,
+            },
+            results: [],
+            threads: [],
+            suites: [],
+            environment: this.environment ?? '',
+            host_data: this.getHostInfo(),
+        };
+        for (const result of this.results) {
+            report.stats.total++;
+            switch (result.execution.status) {
+                case models_1.TestStatusEnum.passed:
+                    report.stats.passed++;
+                    break;
+                case models_1.TestStatusEnum.failed:
+                    report.stats.failed++;
+                    break;
+                case models_1.TestStatusEnum.skipped:
+                    report.stats.skipped++;
+                    break;
+                case models_1.TestStatusEnum.invalid:
+                    report.stats.broken++;
+                    break;
+                case models_1.TestStatusEnum.blocked:
+                    report.stats.muted++;
+                    break;
+            }
+            if (result.execution.thread && !report.threads.includes(result.execution.thread)) {
+                report.threads.push(result.execution.thread);
+            }
+            report.execution.cumulative_duration += result.execution.duration ?? 0;
+            report.results.push({
+                duration: result.execution.duration ?? 0,
+                id: result.id,
+                status: result.execution.status,
+                thread: result.execution.thread,
+                title: result.title,
+            });
+            if (result.attachments.length > 0) {
+                result.attachments = this.writer.writeAttachment(result.attachments);
+            }
+            result.steps = this.copyStepAttachments(result.steps);
+            result.run_id = this.runId ?? null;
+            await this.writer.writeTestResult(result);
+        }
+        const path = await this.writer.writeReport(report);
+        this.logger.log(`Report saved to ${path}`);
+    }
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    copyStepAttachments(steps) {
+        for (const step of steps) {
+            if (step.attachments.length > 0) {
+                step.attachments = this.writer.writeAttachment(step.attachments);
+            }
+            if (step.steps.length > 0) {
+                step.steps = this.copyStepAttachments(step.steps);
+            }
+        }
+        return steps;
+    }
+    /**
+     * @returns {HostData}
+     */
+    getHostInfo() {
+        return {
+            system: process.platform,
+            node: this.getComputerName(),
+            release: os.release(),
+            version: this.getDetailedOSInfo(),
+            machine: os.arch(),
+            python: '',
+            pip: '',
+            node_version: cp.execSync('node --version').toString().trim(),
+            npm: cp.execSync('npm --version').toString().trim(),
+        };
+    }
+    /**
+     * @returns {string}
+     */
+    getComputerName() {
+        switch (process.platform) {
+            case 'win32':
+                return process.env['COMPUTERNAME'] ?? '';
+            case 'darwin':
+                return cp.execSync('scutil --get ComputerName').toString().trim();
+            case 'linux': {
+                const prettyname = cp.execSync('hostnamectl --pretty').toString().trim();
+                return prettyname === '' ? os.hostname() : prettyname;
+            }
+            default:
+                return os.hostname();
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    getDetailedOSInfo() {
+        if (process.platform === 'darwin') {
+            return cp.execSync('uname -a').toString().trim();
+        }
+        else {
+            return `${os.type()} ${os.release()} ${os.arch()}`;
+        }
+    }
+}
+exports.ReportReporter = ReportReporter;

package/dist/reporters/testops-reporter.d.ts

@@ -0,0 +1,179 @@
+import { QaseApiInterface, ResultStepStatus, TestStepResultCreateStatusEnum } from 'qaseio';
+import { AbstractReporter } from './abstract-reporter';
+import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
+import { LoggerInterface } from '../utils/logger';
+export type TestOpsRunType = {
+    id?: number | undefined;
+    title: string;
+    description: string;
+    complete?: boolean | undefined;
+};
+export type TestOpsPlanType = {
+    id?: number | undefined;
+};
+export type TestOpsBatchType = {
+    size?: number | undefined;
+};
+export type TestOpsOptionsType = {
+    project: string;
+    uploadAttachments?: boolean | undefined;
+    run: TestOpsRunType;
+    plan: TestOpsPlanType;
+    batch?: TestOpsBatchType;
+    defect?: boolean | undefined;
+    useV2?: boolean | undefined;
+};
+/**
+ * @class TestOpsReporter
+ * @extends AbstractReporter
+ */
+export declare class TestOpsReporter extends AbstractReporter {
+    private api;
+    /**
+     * @type {Record<TestStatusEnum, string>}
+     */
+    static statusMap: Record<TestStatusEnum, string>;
+    /**
+     * @type {Record<StepStatusEnum, ResultStepStatus>}
+     */
+    static stepStatusMap: Record<StepStatusEnum, ResultStepStatus>;
+    /**
+     * @type {Record<StepStatusEnum, ResultStepStatus>}
+     */
+    static stepStatusMapV1: Record<StepStatusEnum, TestStepResultCreateStatusEnum>;
+    /**
+     * @type {string}
+     * @private
+     */
+    private readonly baseUrl;
+    /**
+     * @type {string}
+     * @private
+     */
+    private readonly projectCode;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly isUploadAttachments;
+    /**
+     * @type {TestOpsRunType}
+     * @private
+     */
+    private run;
+    /**
+     * @type { number | undefined}
+     * @private
+     */
+    private readonly environment;
+    /**
+     * @type {TestResultType[]}
+     * @private
+     */
+    private readonly batchSize;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly useV2;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly defect;
+    /**
+     * @type {number}
+     * @private
+     */
+    private firstIndex;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private isTestRunReady;
+    /**
+     * @param {LoggerInterface} logger
+     * @param {ReporterOptionsType & TestOpsOptionsType} options
+     * @param {QaseApiInterface} api
+     * @param {number} environment
+     */
+    constructor(logger: LoggerInterface, options: TestOpsOptionsType, api: QaseApiInterface, environment?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    private checkOrCreateTestRun;
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    private publishResults;
+    /**
+     * @returns {Promise<void>}
+     */
+    publish(): Promise<void>;
+    /**
+     * @param {TestResultType} result
+     * @returns Promise<ResultCreateV2>
+     * @private
+     */
+    private transformTestResult;
+    /**
+     * @param {TestResultType} result
+     * @returns Promise<ResultCreate>
+     * @private
+     */
+    private transformTestResultV1;
+    /**
+     * @returns {ResultExecution}
+     * @private
+     * @param {TestExecution} exec
+     */
+    private getExecution;
+    /**
+     * @param {Relation | null} relation
+     * @returns {ResultRelations}
+     * @private
+     */
+    private getRelation;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns Promise<ResultStep[]>
+     * @private
+     */
+    private transformSteps;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns Promise<TestStepResultCreate[]>
+     * @private
+     */
+    private transformStepsV1;
+    /**
+     * @param {number} runId
+     * @returns {Promise<void>}
+     * @private
+     */
+    private checkRun;
+    /**
+     * @param {string} title
+     * @param {string} description
+     * @param {number | undefined} environment
+     * @returns {Promise<IdResponse>}
+     * @private
+     */
+    private createRun;
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    private uploadAttachments;
+}