@testomatio/reporter 2.9.3-beta-vitestmeta-2 → 2.9.3-beta.3-allure-links

package/README.md

@@ -76,6 +76,7 @@ npx testomatio-reporter <command> [options]
 | [TestCafe](./docs/frameworks.md#testcafe)       | [Detox](./docs/frameworks.md#detox)           | [Codeception](https://github.com/testomatio/php-reporter) |
 | [Newman (Postman)](./docs/frameworks.md#newman) | [JUnit](./docs/junit.md#junit)                | [NUnit](./docs/junit.md#nunit)                            |
 | [PyTest](./docs/junit.md#pytest)                | [PHPUnit](./docs/junit.md#phpunit)            | [Protractor](./docs/frameworks.md#protractor)             |
+| [Allure](./docs/allure.md)                      |                                               |                                                           |
 
 or **any [other via JUnit](./docs/junit.md)** report....
 
@@ -137,9 +138,10 @@ Bring this reporter on CI and never lose test results again!
   - [HTML report](./docs/pipes/html.md)
   - [Markdown report](./docs/pipes/markdown.md)
   - [Bitbucket](./docs/pipes/bitbucket.md)
-- 🔗 [Linking Tests](./docs/linking-tests.md)
-- 📓 [JUnit](./docs/junit.md)
+- 📓 [JUnit Reports](./docs/junit.md)
 - 🗄️ [Artifacts](./docs/artifacts.md)
+- 🔬 [Allure Reports](./docs/allure.md)
+- 🔗 [Linking Tests](./docs/linking-tests.md)
 - 🔂 [Workflows](./docs/workflows.md)
 - 🖊️ [Logger](./docs/logger.md)
 - 🪲 [Debug File Format](./docs/debug-file-format.md)

package/lib/adapter/codecept.js

@@ -237,7 +237,6 @@ async function uploadAttachments(client, attachments, messagePrefix, attachmentT
     if (client.uploader.isEnabled) {
         log_js_1.log.info(`Attachments: ${messagePrefix} ${attachments.length} ${attachmentType} ...`);
     }
-    await Promise.all(client.pipes?.map(pipe => pipe.addArtifacts?.(attachments)) || []);
     const promises = attachments.map(async (attachment) => {
         const { rid, title, path, type } = attachment;
         const file = { path, type, title };

package/lib/adapter/playwright.js

@@ -51,8 +51,13 @@ class PlaywrightReporter {
         const { title } = test;
         const { error, duration } = result;
         const pwAttachments = (result.attachments || []).filter(a => a.body || a.path);
-        const files = buildArtifactFiles(pwAttachments, attachment => this.#getArtifactPath(attachment), title);
-        const artifactsForUpload = processArtifactsForUpload(pwAttachments);
+        const files = pwAttachments
+            .map(att => ({
+            path: this.#getArtifactPath(att),
+            title: att.name || title,
+            type: att.contentType,
+        }))
+            .filter(f => f.path);
         const suite_title = test.parent ? test.parent?.title : path_1.default.basename(test?.location?.file);
         const rid = test.id || test.testId || (0, uuid_1.v4)();
         /**
@@ -139,7 +144,7 @@ class PlaywrightReporter {
         this.uploads.push({
             rid: `${rid}-${project.name}`,
             title: test.title,
-            files: artifactsForUpload,
+            files: pwAttachments,
             file: test.location?.file,
         });
         // remove empty uploads
@@ -205,22 +210,6 @@ function checkStatus(status) {
         passed: constants_js_1.STATUS.PASSED,
     }[status] || constants_js_1.STATUS.FAILED);
 }
-function buildArtifactFiles(attachments, getArtifactPath, title) {
-    return attachments
-        .filter(isScreenshotArtifact)
-        .map(attachment => ({
-        path: getArtifactPath(attachment),
-        title: attachment.name || title,
-        type: attachment.contentType,
-    }))
-        .filter(file => file.path);
-}
-function processArtifactsForUpload(attachments) {
-    return attachments.filter(attachment => !isScreenshotArtifact(attachment));
-}
-function isScreenshotArtifact(attachment) {
-    return attachment?.contentType === 'image/png' && attachment?.name === 'screenshot';
-}
 function appendStep(step, shift = 0) {
     // nesting too deep, ignore those steps
     if (shift >= 10)

package/lib/adapter/vitest.js

@@ -393,10 +393,7 @@ function normalizeVitestTest(test) {
             file,
             suiteTitle,
             logs: '',
-            meta: {
-                ...(test.task?.meta || {}),
-                ...(typeof test.meta === 'function' ? test.meta() : test.meta || {}),
-            },
+            meta: typeof test.meta === 'function' ? test.meta() : {},
         };
     }
     return {

package/lib/allureReader.d.ts

@@ -0,0 +1,208 @@
+export default AllureReader;
+declare class AllureReader {
+    constructor(opts?: {});
+    requestParams: {
+        apiKey: any;
+        url: any;
+        title: string;
+        env: string;
+        group_title: string;
+        batchMode: "manual";
+    };
+    runId: any;
+    opts: {};
+    withPackage: any;
+    store: {};
+    pipesPromise: Promise<any[]>;
+    _tests: any[];
+    stats: {};
+    suites: {};
+    uploader: S3Uploader;
+    version: any;
+    set tests(value: any[]);
+    get tests(): any[];
+    createRun(): Promise<any[]>;
+    pipes: any;
+    parse(resultsPattern: any): {};
+    parseContainerFiles(containerFiles: any): void;
+    processAllureResult(result: any, resultsDir: any): {
+        rid: any;
+        title: any;
+        status: any;
+        suite_title: any;
+        file: string;
+        run_time: number;
+        steps: any;
+        message: any;
+        stack: any;
+        meta: {};
+        links: {
+            label: string;
+        }[];
+        artifacts: any[];
+        create: boolean;
+        overwrite: boolean;
+    };
+    mapStatus(status: any): any;
+    /**
+     * Map an Allure step status to the Testomat.io Step status enum
+     * (`passed | failed | none | custom`, see testomat-api-definition.yml).
+     *
+     * Allure marks a step `broken` when it threw an unexpected error — that is a
+     * failure for reporting purposes, matching how `mapStatus` treats tests.
+     * `skipped` and anything unknown/absent become `none` (the neutral value),
+     * since the step enum has no `skipped`.
+     *
+     * @param {string} status - Allure step status
+     * @returns {'passed'|'failed'|'none'} Testomat.io step status
+     */
+    mapStepStatus(status: string): "passed" | "failed" | "none";
+    extractSuiteTitle(result: any): any;
+    stripNamespace(suiteName: any): any;
+    extractFile(result: any): string;
+    getFileExtension(result: any): any;
+    extractMeta(result: any): {};
+    extractLinks(result: any): {
+        label: string;
+    }[];
+    /**
+     * Extract all Testomat.io test ids from Allure links so reported results match
+     * existing cases instead of creating duplicates.
+     *
+     * A test may carry several `@TmsLink`s (e.g. `@TmsLinks(@TmsLink("…"), @TmsLink("…"))`),
+     * each producing a link with `type: "tms"`. Some exporters omit the type but still point
+     * the link URL at a Testomat.io test page; both are accepted. The link `name` is used as
+     * the id (falling back to the id segment of a Testomat.io URL). Ids are normalized and
+     * de-duplicated, preserving order so the first one stays the primary `test_id`.
+     *
+     * @param {object} result - Parsed Allure result JSON
+     * @returns {string[]} Normalized test ids (possibly empty)
+     */
+    extractTmsIds(result: object): string[];
+    /**
+     * The primary Testomat.io test id (the first `@TmsLink`), or null when there is none.
+     *
+     * @param {object} result - Parsed Allure result JSON
+     * @returns {string|null}
+     */
+    extractTestId(result: object): string | null;
+    /**
+     * Attach additional linked test cases to a reported test as `{ test: id }` link entries
+     * (the same shape `linkTest()` uses), so a single result updates every case it is linked
+     * to — not just the primary `test_id`. Existing links are preserved; duplicates skipped.
+     *
+     * @param {object} test - converted test
+     * @param {string[]} ids - additional test ids to link
+     */
+    addLinkedTestIds(test: object, ids: string[]): void;
+    /**
+     * Normalize a value into a Testomat.io test id.
+     *
+     * Testomat.io test ids are exactly **8 word characters**. The value may arrive bare
+     * (`1a2b3c4d`), or carrying the `T` / `@T` markers Testomat uses in code and titles
+     * (`T1a2b3c4d`, `@T1a2b3c4d`). The markers are removed only when doing so still leaves
+     * a valid 8-char id, so a real id that happens to start with `T` is preserved.
+     *
+     * Anything that does not resolve to a valid 8-char id — a numeric Allure TestOps id
+     * like `12345`, a JIRA key, a 6-digit TMS number — is rejected (returns null) so we
+     * never send an unmatchable id that would create duplicates.
+     *
+     * @param {string|number|null|undefined} value
+     * @returns {string|null} The bare 8-char id, or null when the value is not a valid id
+     */
+    normalizeTestId(value: string | number | null | undefined): string | null;
+    /**
+     * Recover a Testomat.io test id from the `@TmsLink("…")` annotation in test source.
+     *
+     * Allure does not emit link annotations for skipped (`@Ignore` / `@Disabled`) tests,
+     * so their results carry no `tms` link and `extractTestId` returns null — which makes
+     * the server create a duplicate case. The id still lives in the source, on the test
+     * method, so we read it from there as a fallback.
+     *
+     * The lookup is method-scoped: we locate the test method declaration by name, collect
+     * its annotation/comment block (the lines directly above it, up to the previous code
+     * construct) and read every `@TmsLink` from it — so an unrelated method's annotation can
+     * never be picked up. Both `@TmsLink("…")` and the container forms
+     * `@TmsLinks(@TmsLink("…"), @TmsLink("…"))` (single- or multi-line) are supported.
+     *
+     * @param {string} contents - full source file
+     * @param {object} test - converted test (uses `title`)
+     * @returns {string[]} normalized 8-char ids in source order (possibly empty)
+     */
+    extractTmsIdsFromSource(contents: string, test: object): string[];
+    /**
+     * The primary `@TmsLink` id for a test method in source, or null. Convenience wrapper
+     * around {@link extractTmsIdsFromSource}.
+     *
+     * @param {string} contents - full source file
+     * @param {object} test - converted test (uses `title`)
+     * @returns {string|null}
+     */
+    extractTmsIdFromSource(contents: string, test: object): string | null;
+    convertSteps(steps: any, depth?: number): any;
+    /**
+     * Check whether any step in the given (already converted) subtree already
+     * carries an `error`. Used to keep the failure message on the deepest failed
+     * step only, instead of repeating it on every ancestor in the failure chain.
+     *
+     * @param {Array<object>|undefined} steps - converted child steps
+     * @returns {boolean}
+     */
+    subtreeHasError(steps: Array<object> | undefined): boolean;
+    /**
+     * Build the `error` payload for a failed step from its Allure `statusDetails`.
+     *
+     * Allure stores the failure message and stack trace (which includes the failing
+     * source line) in `statusDetails` on the step itself. We only surface it for
+     * failed/broken steps — passing or skipped steps carry no error. Returns null
+     * when there is no usable failure information so the field is omitted entirely.
+     *
+     * @param {object} step - Allure step
+     * @returns {{message: string, stack: string}|null}
+     */
+    extractStepError(step: object): {
+        message: string;
+        stack: string;
+    } | null;
+    calculateRunTime(item: any): number;
+    convertParameters(parameters: any): {};
+    combineRetryAttempts(attempts: any): any;
+    calculateStats(): {};
+    fetchSourceCode(): void;
+    getLanguage(): any;
+    /**
+     * Link tests to their Testomat.io cases by reading `@TmsLink` from source for tests that
+     * carry no `{ test: … }` link yet. This rescues skipped (`@Ignore` / `@Disabled`) tests,
+     * whose Allure results drop the `@TmsLink` link and would otherwise create duplicate
+     * cases. Every `@TmsLink` on the method is linked (consistent with executed tests); the
+     * `test_id` is left untouched — links and test_id are separate concerns.
+     *
+     * Opt-in: only runs when `--java-tests` (a source root) is provided. The source files are
+     * indexed once by basename; for each not-yet-linked test we read the candidate file(s)
+     * matching its `testFile` / class name and parse the method's `@TmsLink`(s).
+     */
+    recoverTmsLinksFromSource(): void;
+    /**
+     * Build (and cache) a basename -> [absolute paths] index of source files under `root`.
+     * Walks synchronously, skipping common build/dependency directories.
+     *
+     * @param {string} root
+     * @returns {Map<string, string[]>}
+     */
+    indexSourceFiles(root: string): Map<string, string[]>;
+    _sourceIndex: Map<any, any>;
+    /**
+     * Candidate source file paths for a test, looked up in the basename index.
+     * Uses the `testFile` meta label (e.g. `Foo.kt`) and the class name from `file`,
+     * trying both `.kt` and `.java` extensions. Ambiguity (same basename in several
+     * dirs) is harmless: only the file that actually declares the method will match.
+     *
+     * @param {object} t
+     * @param {Map<string, string[]>} index
+     * @returns {string[]}
+     */
+    sourceCandidatesForTest(t: object, index: Map<string, string[]>): string[];
+    uploadArtifacts(): Promise<void>;
+    uploadData(): Promise<any[]>;
+}
+import { S3Uploader } from './uploader.js';