@wdio/browserstack-service 9.30.2 → 9.31.0

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

@@ -18,7 +18,10 @@ export default class AccessibilityModule extends BaseModule {
         [key: string]: unknown;
     }>;
     currentTestName: string | null;
+    currentHookRunUuid: string | null;
     constructor(accessibilityConfig: Accessibility, isNonBstackA11y: boolean);
+    onHookStart(args: Record<string, unknown>): Promise<void>;
+    onHookEnd(): Promise<void>;
     onBeforeExecute(): Promise<void>;
     private commandWrapper;
     onBeforeTest(args: Record<string, unknown>): Promise<void>;

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

@@ -18,9 +18,25 @@ export default class CustomTagsModule extends BaseModule {
     logger: typeof BStackLogger;
     name: string;
     static MODULE_NAME: string;
+    /**
+     * Tags set before a per-test context exists — e.g. from a `beforeEach` hook, which
+     * WDIO runs BEFORE `beforeTest` tracks the test instance. Buffered here and flushed
+     * into the test at test start (onBeforeTest), then reset per-test, so hook-set tags
+     * land on the test (parity with Java @Before). Process-local (one module per worker)
+     * and Mocha runs tests serially, so a plain object is safe.
+     */
+    private pendingTestLevelTags;
     constructor();
     getModuleName(): string;
     onBeforeExecute(): Promise<void>;
+    /**
+     * At each test start (TEST/PRE — after beforeTest tracks the instance), flush any
+     * tags buffered before the test had a context (e.g. set in a `beforeEach` hook — see
+     * the setCustomTags closure) into the tracked instance's custom_metadata via the SAME
+     * merge path as explicit setCustomTags, then reset the buffer for the next test — so
+     * hook-set tags union onto the test (parity with Java @Before).
+     */
+    onBeforeTest(args: Record<string, unknown>): Promise<void>;
     /**
      * If the test framework is currently inside a hook, merge custom_metadata onto
      * the last-started hook record so the binary receives hook.custom_metadata.

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

@@ -8,6 +8,19 @@ export default class TestHubModule extends BaseModule {
     testhubConfig: unknown;
     name: string;
     static MODULE_NAME: string;
+    /**
+     * Mocha-only: the TEST/POST (TestRunFinished) send deferred past the after-each hook
+     * window. WDIO fires `afterTest` (which triggers TEST/POST) BEFORE the user's
+     * `afterEach` hooks run, so custom tags set in `afterEach` would otherwise miss the
+     * event. The payload (`eventJson`) is serialized from the instance's live data map at
+     * SEND time, so deferring the send picks up those late merges; uuid / started_at /
+     * ended_at are already stamped in the data and do not drift. The stashed
+     * `args.instance` is the finished test's OWN object — INIT_TEST replaces the tracked
+     * slot with a fresh instance for the next test — so it stays valid across tests.
+     * Flushed at the next test's first event (INIT_TEST / TEST PRE) or, for the worker's
+     * last test, from service.after() via flushPendingTestFinishEvent().
+     */
+    private pendingTestFinish;
     /**
      * Create a new TestHubModule
      */
@@ -19,7 +32,18 @@ export default class TestHubModule extends BaseModule {
     getModuleName(): string;
     onBeforeTest(args: Record<string, unknown>): void;
     onAllTestEvents(args: Record<string, unknown>): void;
-    sendTestFrameworkEvent(args: Record<string, unknown>): Promise<void>;
+    /**
+     * Send a deferred TEST/POST (TestRunFinished) event, if one is pending. The instance's
+     * CURRENT state may have moved on (e.g. LOG events during afterEach), so the send uses
+     * an explicit TEST/POST state override; the payload data itself is read fresh from the
+     * instance so late custom-tag merges are included. Called from onAllTestEvents at the
+     * next test's boundary and from service.after() at worker end.
+     */
+    flushPendingTestFinishEvent(): Promise<void> | undefined;
+    sendTestFrameworkEvent(args: Record<string, unknown>, stateOverride?: {
+        testFrameworkState: string;
+        testHookState: string;
+    }): Promise<void>;
     /**
      * Send test session event to the service
      * @param args containing test session data

package/build/customTags.d.ts

@@ -56,3 +56,17 @@ export declare class CustomTagAccumulator {
     /** Drop the accumulated entry once flushed (avoid unbounded growth). */
     clear(testUuid: string | undefined): void;
 }
+export type MochaHookWindow = 'before_each' | 'after_each' | 'before_all' | 'after_all' | null;
+/**
+ * Classify a Mocha hook title (e.g. '"before each" hook: setup') into a window type.
+ * Derives from getHookType so this and the tracked hook-state — both computed from the
+ * same hook title in service.beforeHook — can never disagree. getHookType anchors on
+ * Mocha's generated '"before each"' prefix (startsWith), so a hook with a custom name
+ * that merely contains another window's phrase (e.g. afterEach('reset before each run'))
+ * is NOT misrouted, unlike a substring match.
+ */
+export declare function classifyMochaHookTitle(title: string | undefined | null): MochaHookWindow;
+/** Set by the service's beforeHook (mocha); cleared by afterHook. */
+export declare function setCurrentMochaHookWindow(window: MochaHookWindow): void;
+/** Read by the CLI CustomTagsModule to route setCustomTags calls made inside hooks. */
+export declare function getCurrentMochaHookWindow(): MochaHookWindow;