vitest-qase-reporter 1.0.0

package/dist/index.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VitestQaseReporter = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+class VitestQaseReporter {
+    reporter;
+    currentSuite = undefined;
+    testMetadata = new Map();
+    /**
+   * @type {RegExp}
+   */
+    static qaseIdRegExp = /\(Qase ID: ([\d,]+)\)/;
+    /**
+   * @param {string} title
+   * @returns {number[]}
+   * @private
+   */
+    static getCaseId(title) {
+        const [, ids] = title.match(VitestQaseReporter.qaseIdRegExp) ?? [];
+        return ids ? ids.split(',').map((id) => Number(id)) : [];
+    }
+    /**
+   * @param {string} title
+   * @returns {string}
+   * @private
+   */
+    static removeQaseIdsFromTitle(title) {
+        const matches = title.match(VitestQaseReporter.qaseIdRegExp);
+        if (matches) {
+            return title.replace(matches[0], '').trimEnd();
+        }
+        return title;
+    }
+    constructor(options = {}) {
+        const composedOptions = (0, qase_javascript_commons_1.composeOptions)(options, {});
+        this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
+            ...composedOptions,
+            frameworkPackage: 'vitest',
+            frameworkName: 'vitest',
+            reporterName: 'vitest-qase-reporter',
+        });
+    }
+    /**
+     * Convert Vitest test result status to Qase TestStatusEnum
+     */
+    convertStatus(result) {
+        switch (result.state) {
+            case 'passed':
+                return qase_javascript_commons_1.TestStatusEnum.passed;
+            case 'failed':
+                return qase_javascript_commons_1.TestStatusEnum.failed;
+            case 'skipped':
+                return qase_javascript_commons_1.TestStatusEnum.skipped;
+            case 'pending':
+                return qase_javascript_commons_1.TestStatusEnum.skipped;
+            default:
+                return qase_javascript_commons_1.TestStatusEnum.skipped;
+        }
+    }
+    /**
+     * Create TestResultType from Vitest TestCase
+     */
+    createTestResult(testCase) {
+        const result = testCase.result();
+        const qaseIds = VitestQaseReporter.getCaseId(testCase.name);
+        const diagnostic = testCase.diagnostic();
+        const testId = testCase.id ?? testCase.name;
+        const metadata = this.testMetadata.get(testId);
+        // Use title from metadata if available, otherwise use test name
+        const testTitle = metadata?.title ?? VitestQaseReporter.removeQaseIdsFromTitle(testCase.name);
+        const testResult = new qase_javascript_commons_1.TestResultType(testTitle);
+        testResult.id = testCase.id ?? '';
+        testResult.signature = testCase.fullName ?? testCase.name;
+        // Set testops_id based on extracted qase IDs
+        if (qaseIds.length > 0) {
+            testResult.testops_id = qaseIds.length === 1 ? qaseIds[0] ?? null : qaseIds;
+        }
+        else {
+            testResult.testops_id = null;
+        }
+        // Set relations for test suite
+        const suiteToUse = metadata?.suite ?? this.currentSuite ?? this.extractSuiteFromTestCase(testCase);
+        if (suiteToUse) {
+            testResult.relations = {
+                suite: {
+                    data: [],
+                },
+            };
+            const suites = suiteToUse.split(' - ');
+            suites.forEach((suite) => {
+                testResult.relations.suite.data.push({ title: suite.trim(), public_id: null });
+            });
+        }
+        // Set execution details
+        testResult.execution.status = this.convertStatus(result);
+        testResult.execution.start_time = diagnostic?.startTime ? diagnostic.startTime / 1000 : null;
+        testResult.execution.end_time = diagnostic?.startTime ? diagnostic.startTime / 1000 + diagnostic.duration : null;
+        testResult.execution.duration = Math.round(diagnostic?.duration || 0);
+        if (result?.errors && result.errors.length > 0) {
+            testResult.execution.stacktrace = result.errors.map((error) => {
+                if (error && typeof error === 'object' && 'stack' in error && 'message' in error) {
+                    return error.stack ?? error.message ?? String(error);
+                }
+                return String(error);
+            }).join('\n');
+            testResult.message = result.errors[0] && typeof result.errors[0] === 'object' && 'message' in result.errors[0]
+                ? String(result.errors[0].message) ?? 'Test failed'
+                : 'Test failed';
+        }
+        if (result.state === 'skipped') {
+            testResult.message = result && typeof result === 'object' && 'note' in result ? result.note ?? null : null;
+        }
+        // Add metadata from annotations
+        if (metadata) {
+            // Add comment if available - store in message field since execution doesn't have comment
+            if (metadata.comment) {
+                testResult.message = metadata.comment;
+            }
+            // Add fields if available
+            if (metadata.fields) {
+                testResult.fields = metadata.fields;
+            }
+            // Add parameters if available
+            if (metadata.parameters) {
+                testResult.params = metadata.parameters;
+            }
+            // Add group parameters if available
+            if (metadata.groupParameters) {
+                testResult.group_params = metadata.groupParameters;
+            }
+            // Add steps if available - create proper TestStepType objects
+            if (metadata.steps.length > 0) {
+                testResult.steps = metadata.steps.map(step => {
+                    const stepObj = new qase_javascript_commons_1.TestStepType();
+                    stepObj.id = Math.random().toString(36).substr(2, 9);
+                    stepObj.data = {
+                        action: step.name,
+                        expected_result: null,
+                        data: null
+                    };
+                    stepObj.execution.status = step.status === 'failed' ? qase_javascript_commons_1.StepStatusEnum.failed : qase_javascript_commons_1.StepStatusEnum.passed;
+                    return stepObj;
+                });
+            }
+            // Add attachments if available
+            if (metadata.attachments.length > 0) {
+                testResult.attachments = metadata.attachments.map(attachment => {
+                    const attachmentModel = {
+                        file_name: attachment.name,
+                        mime_type: attachment.contentType || 'application/octet-stream',
+                        file_path: attachment.path || null,
+                        content: attachment.content || '',
+                        size: attachment.content ? Buffer.byteLength(attachment.content) : 0,
+                        id: Math.random().toString(36).substr(2, 9)
+                    };
+                    return attachmentModel;
+                });
+            }
+        }
+        // Clean up metadata after processing
+        this.testMetadata.delete(testId);
+        return testResult;
+    }
+    onTestRunStart() {
+        this.reporter.startTestRun();
+    }
+    async onTestRunEnd() {
+        await this.reporter.publish();
+    }
+    async onTestCaseResult(testCase) {
+        const testResult = this.createTestResult(testCase);
+        await this.reporter.addTestResult(testResult);
+    }
+    onTestCaseAnnotate(testCase, annotation) {
+        const testId = testCase.id ?? testCase.name;
+        // Initialize metadata if not exists
+        if (!this.testMetadata.has(testId)) {
+            this.testMetadata.set(testId, {
+                steps: [],
+                attachments: []
+            });
+        }
+        const metadata = this.testMetadata.get(testId);
+        if (!metadata)
+            return;
+        // Process qase annotations
+        // Check if this is a qase annotation by looking at the message pattern
+        if (annotation.message && annotation.message.startsWith('Qase ')) {
+            const qaseType = annotation.message.split(':')[0]?.replace('Qase ', '').toLowerCase().replace(' ', '-') ?? '';
+            switch (qaseType) {
+                case 'title': {
+                    metadata.title = annotation.message.replace('Qase Title: ', '');
+                    break;
+                }
+                case 'comment': {
+                    metadata.comment = annotation.message.replace('Qase Comment: ', '');
+                    break;
+                }
+                case 'suite': {
+                    metadata.suite = annotation.message.replace('Qase Suite: ', '');
+                    break;
+                }
+                case 'fields': {
+                    const fieldsData = annotation.message.replace('Qase Fields: ', '');
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const parsed = JSON.parse(fieldsData);
+                        if (typeof parsed === 'object' && parsed !== null) {
+                            metadata.fields = parsed;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse qase fields:', fieldsData);
+                    }
+                    break;
+                }
+                case 'parameters': {
+                    const parametersData = annotation.message.replace('Qase Parameters: ', '');
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const parsed = JSON.parse(parametersData);
+                        if (typeof parsed === 'object' && parsed !== null) {
+                            metadata.parameters = parsed;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse qase parameters:', parametersData);
+                    }
+                    break;
+                }
+                case 'group-parameters': {
+                    const groupParametersData = annotation.message.replace('Qase Group Parameters: ', '');
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        const parsed = JSON.parse(groupParametersData);
+                        if (typeof parsed === 'object' && parsed !== null) {
+                            metadata.groupParameters = parsed;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to parse qase group parameters:', groupParametersData);
+                    }
+                    break;
+                }
+                case 'step-start': {
+                    const stepStartData = annotation.message.replace('Qase Step Start: ', '');
+                    metadata.currentStep = stepStartData;
+                    break;
+                }
+                case 'step-end': {
+                    if (metadata.currentStep) {
+                        metadata.steps.push({ name: metadata.currentStep, status: 'end' });
+                        delete metadata.currentStep;
+                    }
+                    break;
+                }
+                case 'step-failed': {
+                    if (metadata.currentStep) {
+                        metadata.steps.push({ name: metadata.currentStep, status: 'failed' });
+                        delete metadata.currentStep;
+                    }
+                    break;
+                }
+                case 'attachment': {
+                    const attachmentName = annotation.message.replace('Qase Attachment: ', '');
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const attachment = {
+                        name: attachmentName,
+                        ...(annotation.attachment?.path && { path: annotation.attachment.path }),
+                        ...(annotation.attachment?.body && {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            content: typeof annotation.attachment.body === 'string'
+                                ? annotation.attachment.body
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+                                : new TextDecoder().decode(annotation.attachment.body)
+                        }),
+                        ...(annotation.attachment?.contentType && { contentType: annotation.attachment.contentType })
+                    };
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    metadata.attachments.push(attachment);
+                    break;
+                }
+            }
+        }
+    }
+    onTestSuiteReady(testSuite) {
+        this.currentSuite = testSuite.name;
+    }
+    onTestSuiteResult() {
+        this.currentSuite = undefined;
+    }
+    extractSuiteFromTestCase(testCase) {
+        // Extract suite from testCase.fullName or testCase.name
+        // Format is usually "Suite Name > Test Name" or just "Test Name"
+        const fullName = testCase.fullName ?? testCase.name;
+        const parts = fullName.split(' > ');
+        if (parts.length > 1) {
+            // Return the suite part (everything except the last part)
+            return parts.slice(0, -1).join(' > ');
+        }
+        // If no suite separator found, return undefined
+        // The test will be assigned to the default suite
+        return undefined;
+    }
+}
+exports.VitestQaseReporter = VitestQaseReporter;
+exports.default = VitestQaseReporter;

package/dist/vitest.d.ts

@@ -0,0 +1,41 @@
+type StepFunction = () => Promise<void> | void;
+export declare const addQaseId: (name: string, caseIds: number[]) => string;
+type AnnotateFunction = (message: string, options?: unknown) => Promise<void>;
+export interface QaseWrapper {
+    annotate(message: string, options?: unknown): Promise<void>;
+    title(value: string): Promise<void>;
+    comment(value: string): Promise<void>;
+    suite(value: string): Promise<void>;
+    fields(values: Record<string, string>): Promise<void>;
+    parameters(values: Record<string, string>): Promise<void>;
+    groupParameters(values: Record<string, string>): Promise<void>;
+    step(name: string, body: StepFunction): Promise<void>;
+    attach(attach: {
+        name?: string;
+        type?: string;
+        content?: string;
+        paths?: string[];
+    }): Promise<void>;
+}
+export interface TestContextWithQase {
+    qase: QaseWrapper;
+    annotate: AnnotateFunction;
+}
+/**
+ * Higher-order function that extends test context with qase functions
+ * @param testFn - Test function that receives context with qase
+ * @returns Wrapped test function
+ * @example
+ * test('hello world', withQase(async ({ qase, annotate }) => {
+ *   await qase.title("My Test Title");
+ *   await qase.comment("This is a test comment");
+ *
+ *   if (condition) {
+ *     await qase.annotate('this should\'ve errored', 'error');
+ *   }
+ * }));
+ */
+export declare const withQase: <T extends unknown[]>(testFn: (context: TestContextWithQase & T[0]) => unknown) => (context: T[0] & {
+    annotate: AnnotateFunction;
+}) => Promise<unknown>;
+export {};

package/dist/vitest.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withQase = exports.addQaseId = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const path_1 = __importDefault(require("path"));
+// Function to add Qase ID to test name
+const addQaseId = (name, caseIds) => {
+    return `${name} (Qase ID: ${caseIds.join(',')})`;
+};
+exports.addQaseId = addQaseId;
+/**
+ * Create qase wrapper for annotate function
+ * @param annotate - Vitest annotate function
+ * @returns QaseWrapper object with all qase methods
+ */
+const createQaseWrapper = (annotate) => {
+    return {
+        async annotate(message, options) {
+            return await annotate(message, options);
+        },
+        /**
+         * Set a title for the test case
+         * @param {string} value
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.title("Title");
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async title(value) {
+            return await annotate(`Qase Title: ${value}`, { type: 'qase-title', body: value });
+        },
+        /**
+         * Add a comment to the test case
+         * @param {string} value
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.comment("Comment");
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async comment(value) {
+            return await annotate(`Qase Comment: ${value}`, { type: 'qase-comment', body: value });
+        },
+        /**
+         * Set a suite for the test case
+         * @param {string} value
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.suite("Suite");
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async suite(value) {
+            return await annotate(`Qase Suite: ${value}`, { type: 'qase-suite', body: value });
+        },
+        /**
+         * Set fields for the test case
+         * @param {Record<string, string>} values
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.fields({field: "value"});
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async fields(values) {
+            return await annotate(`Qase Fields: ${JSON.stringify(values)}`, { type: 'qase-fields', body: JSON.stringify(values) });
+        },
+        /**
+         * Set parameters for the test case
+         * @param {Record<string, string>} values
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.parameters({param: "value"});
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async parameters(values) {
+            return await annotate(`Qase Parameters: ${JSON.stringify(values)}`, { type: 'qase-parameters', body: JSON.stringify(values) });
+        },
+        /**
+         * Set group parameters for the test case
+         * @param {Record<string, string>} values
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.groupParameters({param: "value"});
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async groupParameters(values) {
+            return await annotate(`Qase Group Parameters: ${JSON.stringify(values)}`, { type: 'qase-group-parameters', body: JSON.stringify(values) });
+        },
+        /**
+         * Add a step to the test case
+         * @param name
+         * @param body
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *    await qase.step("Step", () => {
+         *      expect(true).toBe(true);
+         *    });
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async step(name, body) {
+            await annotate(`Qase Step Start: ${name}`, { type: 'qase-step-start', body: name });
+            try {
+                const runningStep = new qase_javascript_commons_1.QaseStep(name);
+                await runningStep.run(body, async (step) => {
+                    const stepName = 'action' in step.data ? step.data.action : step.data.name;
+                    await annotate(`Qase Step: ${stepName}`, { type: 'qase-step', body: stepName });
+                });
+                await annotate(`Qase Step End: ${name}`, { type: 'qase-step-end', body: name });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                await annotate(`Qase Step Failed: ${name} - ${errorMessage}`, { type: 'qase-step-failed', body: `${name} - ${errorMessage}` });
+                throw error;
+            }
+        },
+        /**
+         * Add an attachment to the test case
+         * @param attach
+         * @example
+         * test('test', withQase(async ({ qase }) => {
+         *   await qase.attach({ name: 'attachment.txt', content: 'Hello, world!', type: 'text/plain' });
+         *   await qase.attach({ paths: ['/path/to/file', '/path/to/another/file']});
+         *     expect(true).toBe(true);
+         * }));
+         */
+        async attach(attach) {
+            if (attach.paths) {
+                for (const file of attach.paths) {
+                    const attachmentName = path_1.default.basename(file);
+                    const contentType = (0, qase_javascript_commons_1.getMimeTypes)(file);
+                    await annotate(`Qase Attachment: ${attachmentName}`, {
+                        type: 'qase-attachment',
+                        body: attachmentName,
+                        attachment: {
+                            path: file,
+                            contentType: contentType
+                        }
+                    });
+                }
+                return;
+            }
+            if (attach.content) {
+                await annotate(`Qase Attachment: ${attach.name ?? 'attachment'}`, {
+                    type: 'qase-attachment',
+                    body: attach.content,
+                    attachment: {
+                        contentType: attach.type ?? 'application/octet-stream',
+                        body: attach.content
+                    }
+                });
+            }
+        }
+    };
+};
+/**
+ * Higher-order function that extends test context with qase functions
+ * @param testFn - Test function that receives context with qase
+ * @returns Wrapped test function
+ * @example
+ * test('hello world', withQase(async ({ qase, annotate }) => {
+ *   await qase.title("My Test Title");
+ *   await qase.comment("This is a test comment");
+ *
+ *   if (condition) {
+ *     await qase.annotate('this should\'ve errored', 'error');
+ *   }
+ * }));
+ */
+const withQase = (testFn) => {
+    return async (context) => {
+        const qase = createQaseWrapper(context.annotate);
+        return await testFn({ ...context, qase });
+    };
+};
+exports.withQase = withQase;