@wdio/browserstack-service 9.39.5 → 9.40.0

package/build/cli/frameworks/testFramework.d.ts

@@ -1,3 +1,4 @@
+import type { Frameworks } from '@wdio/types';
 import type TrackedContext from '../instances/trackedContext.js';
 import TrackedInstance from '../instances/trackedInstance.js';
 import type TestFrameworkInstance from '../instances/testFrameworkInstance.js';
@@ -53,6 +54,18 @@ export default class TestFramework {
    */
     trackEvent(testFrameworkState: State, hookState: State, args?: unknown): void;
     /**
+   * Pin a test the reporter's `fail` is about to report to the test run it belongs to, before
+   * that report is queued.
+   * @param {Frameworks.Test} _test
+   */
+    pinFailedAttempt(_test: Frameworks.Test): void;
+    /**
+   * Wait for test finishes that are still being reported. A module calls this before it reads the
+   * final results of the run (session status, the last deferred test finish).
+   * @returns {Promise<void>}
+   */
+    settleTestFinishes(): Promise<void>;
+    /**
    * run test hooks
    * @param {TestFrameworkInstance} instance
    * @param {TestFrameworkState} testFrameworkState

package/build/cli/frameworks/wdioMochaTestFramework.d.ts

@@ -4,6 +4,40 @@ import type { Frameworks } from '@wdio/types';
 export default class WdioMochaTestFramework extends TestFramework {
     static KEY_HOOK_LAST_STARTED: string;
     static KEY_HOOK_LAST_FINISHED: string;
+    /**
+     * SDK-7843: mocha test attempts that started and have not finished, keyed per attempt.
+     *
+     * wdio runs `afterTest` inside the test's own runnable, after the body. When a test hits
+     * mocha's timeout, mocha fails it (and emits `fail` to reporters) while the body and its
+     * `afterTest` are still pending; mocha then moves on, and with `bail` (or on the worker's last
+     * test) wdio runs `after()` before that `afterTest`. So a test's finish can arrive from the
+     * reporter's `fail`, from a late `afterTest` while another test holds the tracked-instance
+     * slot, or not at all before the session status is marked. Each attempt keeps the instance it
+     * started on, so its finish is reported against its own test run, once.
+     */
+    private openAttempts;
+    /**
+     * The latest attempt started under each `attemptKey`. The key holds only the immediate parent's
+     * title, so two tests in a worker can share it; the later one's TEST/PRE replaces the entry.
+     */
+    private latestAttemptByKey;
+    /**
+     * Attempts by the test's body, then by `attemptKey`. wdio hands beforeTest and afterTest
+     * separate copies of the mocha test (`{ ...context.test }`, with no reference to the runnable),
+     * but both carry its `fn`, so afterTest finds its own attempt even when another test with the
+     * same key has started since. Tests can share one body (`it(name, sharedFn)`), hence the key.
+     */
+    private attemptsByFn;
+    /** The attempt a source's LOG_REPORT/POST resolved; its TEST/POST passes the same `test` object. */
+    private resolvedFinishes;
+    /** Bail cascades owed by failures reported after mocha moved on; settleTestFinishes() runs them. */
+    private owedBailCascades;
+    /** settleTestFinishes() has run its cascades; anything later cascades inline. */
+    private settled;
+    /** One attempt of a test: mocha retries a test as a new runnable with `_currentRetry` + 1. */
+    static attemptKey(test: Frameworks.Test): string;
+    private static currentRetry;
+    private static testBody;
     /**
    * Constructor for the TestFramework
    * @param {Array} testFrameworks - List of Test frameworks
@@ -18,6 +52,73 @@ export default class WdioMochaTestFramework extends TestFramework {
      * @param {*} args
   */
     trackEvent(testFrameworkState: State, hookState: State, args?: Record<string, unknown>): Promise<void>;
+    /**
+     * Whether this failure will be retried, in which case mocha has not dropped anything yet and
+     * the tests after it are still going to run.
+     *
+     * `results.retries` only tracks wdio's spec-file retries — `@wdio/utils` builds it as
+     * `{ attempts: 0, limit: repeatTest }` and `@wdio/mocha-framework` never feeds `mochaOpts.retries`
+     * into it, so under mocha-level retries it stays `{0, 0}` and tells us nothing. Read mocha's own
+     * runnable state for that case, otherwise the cascade fires on the first attempt and reports
+     * tests as skipped that the retry then actually runs. The runnable is the one captured at
+     * TEST/PRE: once mocha fails a timed-out test it moves on, and the suite's shared
+     * `ctx.test` then points at a hook, which inherits the suite's `retries` (SDK-7843).
+     */
+    private hasRetryPending;
+    /**
+     * mocha's `bail` aborts the run on the first failure, so every test the spec had not reached
+     * yet is dropped without emitting any event and never appears on the dashboard. Report them
+     * as skipped — same cascade the failed-hook path uses, from the spec's root suite so sibling
+     * describes are covered too (bail kills the whole spec, not just the failing describe).
+     *
+     * The root can span more than one file when specs are grouped — `MochaAdapter` adds every spec
+     * it is handed to one mocha instance. Cascading across them is still correct: bail aborts that
+     * whole runner, so those tests do not run either.
+     *
+     * Runs as part of the failed test's finish when that comes from afterTest while mocha waits
+     * for it. When mocha has already moved on (the reporter's `fail`, or a timed-out test's late
+     * afterTest), settleTestFinishes() runs it instead: bail has already aborted the spec, and that
+     * still lands before the session status is marked and the last test finish is flushed
+     * (SDK-7843).
+     */
+    private reportBailSkippedTests;
+    /** TEST/PRE: this attempt's finish is owed from here on, against this instance. */
+    private openTestAttempt;
+    /**
+     * The reporter's `fail`, synchronously in mocha's `fail` event (SDK-7843): pin the failed test
+     * to the attempt mocha just failed, the latest with its key. The finish itself is queued (see
+     * skipReporter's enqueueReport) and may run after mocha has started the next test, which can
+     * share the key.
+     */
+    pinFailedAttempt(test: Frameworks.Test): void;
+    /**
+     * Whether mocha already failed this attempt. A failure it retries is not marked: mocha clones
+     * the test, emits `retry` instead of `fail` and leaves the attempt's `state` unset. It only
+     * retries a failure, though, so a later attempt of the same test having started means this
+     * one failed.
+     */
+    private mochaFailed;
+    /**
+     * The attempt a finish belongs to. wdio's afterTest carries the test's body, which identifies
+     * it exactly. The reporter's `fail` has only the title and parent: it is pinned (see
+     * pinFailedAttempt) to the latest attempt with that key, which is the one mocha just failed,
+     * so its queued LOG_REPORT and TEST/POST cannot land on a later same-named test.
+     */
+    private findTestAttempt;
+    /**
+     * LOG_REPORT/POST and TEST/POST of a mocha test: the attempt to report against. Returns
+     * undefined for any other event, and for a test this framework never saw start (resolved as
+     * before); null to drop the event, when the attempt is already finished or another source is
+     * finishing it.
+     */
+    private resolveTestAttempt;
+    /**
+     * Before the session status is marked and the last test finish is flushed: finish every attempt
+     * mocha already failed (or retried) that nothing reported (no reporter is registered when Test
+     * Reporting, Accessibility and Percy are all off), then run the bail cascades owed. Runs after
+     * drainSkipReports(), which waits for the finishes the reporter queued.
+     */
+    settleTestFinishes(): Promise<void>;
     /**
    * Resolve instance for the test framework
    * @param {TestFrameworkState} testFrameworkState

package/build/cli/modules/customTagsModule.d.ts

@@ -28,7 +28,7 @@ export default class CustomTagsModule extends BaseModule {
     private pendingTestLevelTags;
     constructor();
     getModuleName(): string;
-    private isMochaFramework;
+    private isSupportedFramework;
     onBeforeExecute(): Promise<void>;
     /**
      * At each test start (TEST/PRE — after beforeTest tracks the instance), flush any

package/build/cli/skipReporter.d.ts

@@ -1,5 +1,11 @@
 import type { Frameworks } from '@wdio/types';
 import type TestFramework from './frameworks/testFramework.js';
+/**
+ * Queue a report on the one chain every report wdio may not await goes through, so reports never
+ * interleave on the tracker's per-worker tracked-instance slot. service.after() waits for the chain
+ * through drainSkipReports(). Also used by the reporter's `fail` (SDK-7843).
+ */
+export declare function enqueueReport(work: () => Promise<void>, what: string): Promise<void>;
 export declare function markTestStarted(identifier: string): void;
 export declare function drainSkipReports(): Promise<void>;
 export declare function reportSkippedTest(framework: TestFramework, identifier: string, test: Frameworks.Test, suiteTitle?: string, options?: {
@@ -11,7 +17,8 @@ export declare function reportSkippedTest(framework: TestFramework, identifier:
  * suite — report each state-undefined test as skipped, recursing into nested describes.
  *
  * Reports IMMEDIATELY (SDK-7493): every caller of this — the failed-hook cascade in
- * `afterHook` and the bail cascade in `afterTest` — is awaited by wdio, so these reports
+ * `afterHook` and the bail cascade in `afterTest` (or in `after()`, for a failure reported after
+ * mocha moved on, SDK-7843) — is awaited by wdio, so these reports
  * cannot interleave with a live test the way the un-awaited `onTestSkip` path could. They
  * belong to the hook/test being reported, so they must not slide to end-of-run.
  */