@qanalyzer/forge-wdio 1.1.1

package/dist/reporter.js

@@ -0,0 +1,290 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QaWdioReporter = void 0;
+const reporter_1 = __importDefault(require("@wdio/reporter"));
+const forge_commons_1 = require("@qanalyzer/forge-commons");
+const cucumber_tags_1 = require("./cucumber-tags");
+const metadata_manager_1 = require("./metadata-manager");
+const publish_1 = require("./publish");
+const report_builder_1 = require("./report-builder");
+const results_buffer_1 = require("./results-buffer");
+function ancestorTitles(test, suiteStack) {
+    if (suiteStack.length > 0) {
+        return suiteStack.map((s) => s.title).filter((t) => t && t !== '(root)');
+    }
+    if (test.parent && test.parent !== '(root)') {
+        return [test.parent];
+    }
+    return [];
+}
+function failureMessages(test) {
+    const errors = test.errors ?? [];
+    return errors
+        .map((e) => {
+        if (!e)
+            return '';
+        if (typeof e === 'string')
+            return e;
+        const err = e;
+        return err.stack || err.message || String(e);
+    })
+        .filter(Boolean);
+}
+function suiteTags(suite) {
+    const tags = suite.tags;
+    return Array.isArray(tags) ? tags : [];
+}
+/**
+ * WebdriverIO reporter for QAnalyzer.
+ *
+ * Configure:
+ *   reporters: [[QaWdioReporter, { disableWebdriverStepsReporting: true }]]
+ *   // Cucumber:
+ *   reporters: [[QaWdioReporter, { useCucumber: true }]]
+ *
+ * Mocha: each `it()` → FR41 assertion; `qa.step` → `meta.qa.steps`.
+ * Cucumber: each scenario suite → FR41 assertion; Gherkin steps → `meta.qa.steps` (FR135).
+ */
+class QaWdioReporter extends reporter_1.default {
+    qaOptions;
+    disableWebdriverStepsReporting;
+    disableWebdriverScreenshotsReporting;
+    useCucumber;
+    suiteStack = [];
+    currentFile = 'unknown';
+    scenario = null;
+    constructor(options = {}) {
+        const { disableWebdriverStepsReporting = true, disableWebdriverScreenshotsReporting = true, useCucumber = false, outputDir, mode, projectKey, debug, launchName, frameworkPackage, frameworkName, reporterName, fallback, file, ...rest } = options;
+        super({
+            stdout: true,
+            writeStream: process.stdout,
+            outputDir,
+            ...rest,
+        });
+        this.disableWebdriverStepsReporting = disableWebdriverStepsReporting;
+        this.disableWebdriverScreenshotsReporting =
+            disableWebdriverScreenshotsReporting;
+        this.useCucumber = useCucumber;
+        this.qaOptions = {
+            mode,
+            projectKey,
+            debug,
+            launchName,
+            file,
+            frameworkPackage: frameworkPackage ?? '@wdio/cli',
+            frameworkName: frameworkName ?? 'wdio',
+            reporterName: reporterName ?? '@qanalyzer/forge-wdio',
+            fallback,
+        };
+        results_buffer_1.ResultsBuffer.reset(this.qaOptions);
+        forge_commons_1.QAnalyzerReporter.getInstance(this.qaOptions);
+    }
+    onSuiteStart(suite) {
+        if (suite.file) {
+            this.currentFile = suite.file;
+        }
+        if (this.useCucumber && suite.type === 'scenario') {
+            metadata_manager_1.MetadataManager.clear();
+            const tagResult = (0, cucumber_tags_1.applyCucumberTags)(suiteTags(suite));
+            this.scenario = {
+                title: suite.title,
+                file: suite.file || this.currentFile || 'unknown',
+                ancestors: this.suiteStack
+                    .map((s) => s.title)
+                    .filter((t) => t && t !== '(root)'),
+                issueKeys: tagResult.issueKeys,
+                steps: [],
+            };
+            return;
+        }
+        this.suiteStack.push({ uid: suite.uid, title: suite.title });
+    }
+    onSuiteEnd(suite) {
+        if (this.useCucumber && suite.type === 'scenario') {
+            this.finalizeCucumberScenario(suite);
+            return;
+        }
+        const idx = [...this.suiteStack]
+            .reverse()
+            .findIndex((s) => s.uid === suite.uid);
+        if (idx >= 0) {
+            this.suiteStack.splice(this.suiteStack.length - 1 - idx, 1);
+        }
+        else if (this.suiteStack.length > 0) {
+            this.suiteStack.pop();
+        }
+    }
+    onTestStart(test) {
+        if (this.useCucumber) {
+            if (this.scenario) {
+                this.scenario.currentStep = test.title;
+                metadata_manager_1.MetadataManager.push('qa-step-start', test.title);
+            }
+            return;
+        }
+        metadata_manager_1.MetadataManager.clear();
+    }
+    onTestPass(test) {
+        if (this.useCucumber) {
+            this.endCucumberStep(test, 'passed');
+            return;
+        }
+        this.record(test, 'passed');
+    }
+    onTestFail(test) {
+        if (this.useCucumber) {
+            this.endCucumberStep(test, 'failed');
+            return;
+        }
+        this.record(test, 'failed');
+    }
+    onTestSkip(test) {
+        if (this.useCucumber) {
+            this.endCucumberStep(test, 'skipped');
+            return;
+        }
+        this.record(test, 'pending');
+    }
+    onTestRetry(test) {
+        if (this.useCucumber) {
+            this.endCucumberStep(test, test.state === 'failed' ? 'failed' : 'passed');
+            return;
+        }
+        this.record(test, (0, report_builder_1.mapWdioStatus)(test.state));
+    }
+    async onRunnerEnd() {
+        try {
+            await (0, publish_1.publishBufferedResults)();
+        }
+        catch {
+            // Never fail the WDIO run because of reporter publish errors
+        }
+    }
+    endCucumberStep(test, status) {
+        if (!this.scenario)
+            return;
+        const name = test.title || this.scenario.currentStep || 'step';
+        const messages = status === 'failed' ? failureMessages(test) : [];
+        metadata_manager_1.MetadataManager.push('qa-step-end', {
+            name,
+            status: status === 'skipped' ? 'skipped' : status,
+        });
+        this.scenario.steps.push({
+            name,
+            status,
+            failureMessages: messages,
+        });
+        this.scenario.currentStep = undefined;
+    }
+    finalizeCucumberScenario(suite) {
+        const scenario = this.scenario;
+        this.scenario = null;
+        if (!scenario)
+            return;
+        try {
+            const children = [
+                ...(suite.tests ?? []),
+                ...(suite.hooks ?? []),
+            ];
+            const stepStatuses = scenario.steps.map((s) => s.status);
+            const allSkipped = stepStatuses.length > 0 &&
+                stepStatuses.every((s) => s === 'skipped') &&
+                (children.length === 0 ||
+                    children.every((c) => (c.state ?? 'passed') === 'skipped' || c.state === 'passed'));
+            let status = 'passed';
+            if (scenario.steps.some((s) => s.status === 'failed') ||
+                children.some((c) => c.state === 'failed')) {
+                status = 'failed';
+            }
+            else if (allSkipped ||
+                (scenario.steps.length === 0 &&
+                    children.every((c) => (c.state ?? 'skipped') === 'skipped'))) {
+                status = 'pending';
+            }
+            const failureMessages = scenario.steps
+                .filter((s) => s.status === 'failed')
+                .flatMap((s) => s.failureMessages);
+            const entries = metadata_manager_1.MetadataManager.getEntries();
+            let wire = (0, forge_commons_1.qaMetaFromEntries)(entries, {
+                framework: 'wdio',
+                reporter: '@qanalyzer/forge-wdio',
+            });
+            metadata_manager_1.MetadataManager.clear();
+            if (scenario.issueKeys.length > 0) {
+                const key = scenario.issueKeys[0];
+                if (!scenario.title.includes(key)) {
+                    scenario.title = `${scenario.issueKeys.join(' ')} ${scenario.title}`;
+                }
+            }
+            // Prefer buffered Gherkin step outcomes (includes skipped)
+            if (scenario.steps.length > 0) {
+                const stepsWire = scenario.steps.map((s, index) => ({
+                    id: `step-${index}`,
+                    stepType: 'gherkin',
+                    name: s.name,
+                    status: (s.status === 'skipped'
+                        ? 'skipped'
+                        : s.status),
+                }));
+                wire = {
+                    ...(wire ?? {}),
+                    framework: 'wdio',
+                    reporter: '@qanalyzer/forge-wdio',
+                    steps: stepsWire,
+                };
+            }
+            const title = scenario.title;
+            const ancestors = scenario.ancestors;
+            const assertion = {
+                ancestorTitles: ancestors,
+                title,
+                fullName: ancestors.length > 0 ? `${ancestors.join(' ')} ${title}` : title,
+                status,
+                duration: undefined,
+                failureMessages: status === 'failed' ? failureMessages : [],
+            };
+            if (wire) {
+                assertion.meta = { qa: wire };
+            }
+            results_buffer_1.ResultsBuffer.appendAssertion(scenario.file, assertion);
+        }
+        catch {
+            // Never fail the WDIO run
+        }
+    }
+    record(test, state) {
+        try {
+            const entries = metadata_manager_1.MetadataManager.getEntries();
+            const wire = (0, forge_commons_1.qaMetaFromEntries)(entries, {
+                framework: 'wdio',
+                reporter: '@qanalyzer/forge-wdio',
+            });
+            metadata_manager_1.MetadataManager.clear();
+            const ancestors = ancestorTitles(test, this.suiteStack);
+            const title = test.title;
+            const assertion = {
+                ancestorTitles: ancestors,
+                title,
+                fullName: ancestors.length > 0 ? `${ancestors.join(' ')} ${title}` : title,
+                status: (0, report_builder_1.mapWdioStatus)(state),
+                duration: test.duration,
+                failureMessages: state === 'failed' ? failureMessages(test) : [],
+            };
+            if (wire) {
+                assertion.meta = { qa: wire };
+            }
+            const file = test.file ??
+                this.currentFile ??
+                'unknown';
+            results_buffer_1.ResultsBuffer.appendAssertion(file, assertion);
+        }
+        catch {
+            // Never fail the WDIO run
+        }
+    }
+}
+exports.QaWdioReporter = QaWdioReporter;
+exports.default = QaWdioReporter;

package/dist/results-buffer.d.ts

@@ -0,0 +1,17 @@
+import type { OptionsType } from '@qanalyzer/forge-commons';
+import type { WdioSpecInput } from './report-builder';
+/**
+ * In-process collection of specs for publish from reporter and/or afterRunHook.
+ */
+export declare const ResultsBuffer: {
+    options: OptionsType;
+    runStart: number;
+    specs: WdioSpecInput[];
+    published: boolean;
+    reset(options?: OptionsType): void;
+    setOptions(options: OptionsType): void;
+    appendSpec(spec: WdioSpecInput): void;
+    /** Merge assertions into an existing file bucket or create one. */
+    appendAssertion(file: string, assertion: WdioSpecInput["assertions"][number]): void;
+    takeSpecs(): WdioSpecInput[];
+};

package/dist/results-buffer.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultsBuffer = void 0;
+/**
+ * In-process collection of specs for publish from reporter and/or afterRunHook.
+ */
+exports.ResultsBuffer = {
+    options: {},
+    runStart: Date.now(),
+    specs: [],
+    published: false,
+    reset(options = {}) {
+        this.options = options;
+        this.runStart = Date.now();
+        this.specs = [];
+        this.published = false;
+    },
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    },
+    appendSpec(spec) {
+        this.specs.push(spec);
+    },
+    /** Merge assertions into an existing file bucket or create one. */
+    appendAssertion(file, assertion) {
+        let spec = this.specs.find((s) => s.name === file);
+        if (!spec) {
+            spec = {
+                name: file,
+                startTime: this.runStart,
+                endTime: Date.now(),
+                assertions: [],
+            };
+            this.specs.push(spec);
+        }
+        spec.assertions.push(assertion);
+        spec.endTime = Date.now();
+    },
+    takeSpecs() {
+        const out = this.specs;
+        this.specs = [];
+        return out;
+    },
+};

package/dist/service.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WDIO service for QAnalyzer (FR123).
+ *
+ * Register: `services: [[QaWdioService, { disableWebdriverScreenshotsReporting: false }]]`
+ *
+ * On test failure, captures a still-image screenshot (no video) and uploads via
+ * Forge when configured (FR133). Cucumber: `afterScenario` (FR135). Never fails the WDIO run.
+ */
+export type QaWdioServiceOptions = {
+    /** When true (default), skip automatic failure screenshots. */
+    disableWebdriverScreenshotsReporting?: boolean;
+};
+type AfterTestResult = {
+    passed?: boolean;
+    error?: Error;
+};
+type TestLike = {
+    title?: string;
+    fullTitle?: string | (() => string);
+};
+type ScenarioLike = {
+    title?: string;
+    name?: string;
+    tags?: Array<{
+        name?: string;
+    } | string>;
+};
+type WorldLike = {
+    passed?: boolean;
+    error?: Error;
+};
+export declare class QaWdioService {
+    private readonly disableScreenshots;
+    constructor(options?: QaWdioServiceOptions);
+    before(): void;
+    beforeTest(): void;
+    afterTest(test: TestLike, _context: unknown, result: AfterTestResult): Promise<void>;
+    /**
+     * Cucumber / Gherkin failure still-image (FR135 + FR133).
+     * WDIO cucumber framework invokes this after each scenario.
+     */
+    afterScenario(world: WorldLike, result: {
+        passed?: boolean;
+        error?: Error;
+    } | undefined, scenario: ScenarioLike): Promise<void>;
+    after(): void;
+}
+export {};

package/dist/service.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * WDIO service for QAnalyzer (FR123).
+ *
+ * Register: `services: [[QaWdioService, { disableWebdriverScreenshotsReporting: false }]]`
+ *
+ * On test failure, captures a still-image screenshot (no video) and uploads via
+ * Forge when configured (FR133). Cucumber: `afterScenario` (FR135). Never fails the WDIO run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QaWdioService = void 0;
+const forge_commons_1 = require("@qanalyzer/forge-commons");
+const failure_screenshot_buffer_1 = require("./failure-screenshot-buffer");
+function resolveTitle(test) {
+    if (typeof test.fullTitle === 'function') {
+        try {
+            return test.fullTitle() || test.title || 'unknown';
+        }
+        catch {
+            // fall through
+        }
+    }
+    if (typeof test.fullTitle === 'string' && test.fullTitle) {
+        return test.fullTitle;
+    }
+    return test.title || 'unknown';
+}
+function scenarioTitle(scenario) {
+    return scenario.title || scenario.name || 'unknown';
+}
+function scenarioTagNames(scenario) {
+    if (!Array.isArray(scenario.tags))
+        return [];
+    return scenario.tags
+        .map((t) => (typeof t === 'string' ? t : t?.name || ''))
+        .filter(Boolean);
+}
+function browserRef() {
+    const g = globalThis;
+    return g.browser;
+}
+async function captureFailureScreenshot(label, issueKeySources) {
+    const browser = browserRef();
+    if (!browser?.takeScreenshot)
+        return;
+    const b64 = await browser.takeScreenshot();
+    if (!b64)
+        return;
+    const content = Buffer.from(b64, 'base64');
+    const outcome = await (0, forge_commons_1.uploadAttachmentForQa)({
+        fileName: 'screenshot.png',
+        mimeType: 'image/png',
+        content,
+        issueKeySources,
+    });
+    failure_screenshot_buffer_1.FailureScreenshotBuffer.add(label, outcome.attachment);
+}
+class QaWdioService {
+    disableScreenshots;
+    constructor(options = {}) {
+        this.disableScreenshots =
+            options.disableWebdriverScreenshotsReporting ?? true;
+    }
+    before() {
+        failure_screenshot_buffer_1.FailureScreenshotBuffer.clear();
+    }
+    beforeTest() {
+        // no-op
+    }
+    async afterTest(test, _context, result) {
+        if (this.disableScreenshots)
+            return;
+        if (result?.passed)
+            return;
+        const title = resolveTitle(test);
+        try {
+            await captureFailureScreenshot(test.title || title, [title, test.title]);
+        }
+        catch {
+            // Never fail the WDIO run
+        }
+    }
+    /**
+     * Cucumber / Gherkin failure still-image (FR135 + FR133).
+     * WDIO cucumber framework invokes this after each scenario.
+     */
+    async afterScenario(world, result, scenario) {
+        if (this.disableScreenshots)
+            return;
+        const passed = result?.passed ?? world?.passed;
+        if (passed)
+            return;
+        const title = scenarioTitle(scenario);
+        const tags = scenarioTagNames(scenario);
+        try {
+            await captureFailureScreenshot(title, [title, ...tags]);
+        }
+        catch {
+            // Never fail the WDIO run
+        }
+    }
+    after() {
+        // no-op
+    }
+}
+exports.QaWdioService = QaWdioService;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@qanalyzer/forge-wdio",
+  "version": "1.1.1",
+  "description": "QAnalyzer WebdriverIO reporter + service \u2014 ingest or file modes via @qanalyzer/forge-commons",
+  "keywords": [
+    "qanalyzer",
+    "webdriverio",
+    "wdio",
+    "reporter",
+    "testing",
+    "jira"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "default": "./dist/helpers.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "npm run clean && npx tsc --project tsconfig.build.json && cp -R src/__fixtures__ dist/__fixtures__",
+    "clean": "rm -rf dist",
+    "test": "npm run build && node --test dist/__tests__/**/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "dependencies": {
+    "@cucumber/messages": "34.1.0",
+    "@wdio/reporter": "^9.29.1",
+    "@qanalyzer/forge-commons": "^1.1.1"
+  },
+  "peerDependencies": {
+    "@wdio/cucumber-framework": ">=8.0.0",
+    "@wdio/mocha-framework": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@wdio/mocha-framework": {
+      "optional": true
+    },
+    "@wdio/cucumber-framework": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10"
+  },
+  "license": "Apache-2.0"
+}