@virag8/azure-devops-test-publisher 1.0.1 → 1.2.2

package/README.md

@@ -5,12 +5,17 @@ Publish automated test results and failure screenshots from WebdriverIO (Mocha o
 ## Features
 
 - **Single shared Test Run** — creates one Azure DevOps Test Run for the whole suite in the launcher process and shares its id with all parallel workers via an environment variable, so results from every spec land in the same run.
+- **Only executed tests appear in the run** — the run is created empty and test points are attached as tests finish, so cases in the suite that never ran are not left sitting in an _In progress_ state.
 - **Mocha support** — extracts the Azure DevOps test case id from a test title (e.g. `C1234 login works`) via the `afterTest` hook.
 - **Cucumber / BDD support** — extracts the test case id from a scenario's `@C1234` tag, falling back to the scenario name, via the `afterScenario` hook.
 - **Custom case id pattern** — override the default `C123`/`#123` matcher with your own regex (e.g. `TC-(\d+)`) via `caseIdPattern`.
 - **Automatic failure screenshots** — captures a browser screenshot and attaches it to the Azure DevOps result whenever a test/scenario fails (toggle with `screenshotOnFailure`).
-- **Run reuse** — publish into an existing run (`runId`), or keep a single run open across multiple publishes (`reuseTestRun` / `keepRunOpen`) instead of creating a new run every time.
+- **Configuration-aware publishing** — scope a publish to a single Azure DevOps configuration (Android vs iOS, Chrome vs Firefox, …) so parallel jobs never overwrite each other's results for the same test case.
+- **Run reuse** — publish into an existing run (`runId`), or keep a single run open across multiple publishes (`reuseTestRun` / `keepRunOpen`) instead of creating a new run every time. A run is only created when no run id is supplied — `0` counts as "not supplied".
+- **"Run by" populated** — results are stamped with the identity that owns the PAT instead of showing an empty _Run by_ column.
 - **Point pre-fetch** — pass already-fetched test points via `PublishOptions.points` to skip a redundant Azure DevOps API call.
+- **Fail-fast option validation** — a missing `orgUrl`, `projectId`, `planId` or `suiteId` throws a typed `AzureDevOpsConfigError` listing every offending key, at construction time rather than mid-run.
+- **Actionable diagnostics** — warnings name the project, plan, suite, configuration and the exact test case ids that could not be matched.
 - **Resilient publishing** — publish failures are caught and logged so a flaky Azure DevOps API never fails the test run itself.
 - **Standalone reporter service** — `AzureDevOpsReporterService` for custom/non-service integrations that just need `afterTest` + `onComplete` hooks.
 - **Quiet by default** — set `debug: true` to log raw Azure DevOps API payloads while troubleshooting.
@@ -41,7 +46,7 @@ exports.config = {
       {
         orgUrl: process.env.AZURE_ORG_URL,
         token: process.env.AZURE_PAT,
-        projectName: "MyProject", // name or GUID
+        projectId: "MyProject", // name or GUID
         planId: 123,
         suiteId: 456,
         screenshotOnFailure: true, // optional, defaults to true
@@ -85,6 +90,97 @@ If no tag is present, the case id is parsed from the scenario name instead.
 
 The pattern must contain exactly one capturing group for the numeric id.
 
+### Test configurations (Android vs iOS, Chrome vs Firefox, …)
+
+If the same test case exists in your suite under several Azure DevOps _configurations_, tell each worker which configuration it represents. Without this, a result published for one configuration can overwrite another configuration's result for the same case.
+
+```js
+{
+  configurationId: Number(process.env.ADO_CONFIGURATION_ID), // e.g. 1042 = Android
+}
+```
+
+With `configurationId` set, the service:
+
+- attaches only the test point belonging to that configuration to the run, and
+- updates only the result for that configuration, leaving the others untouched.
+
+Run one WebdriverIO process per configuration:
+
+```bash
+ADO_CONFIGURATION_ID=1042 npx wdio run wdio.android.conf.ts
+ADO_CONFIGURATION_ID=1043 npx wdio run wdio.ios.conf.ts
+```
+
+Find the id under **Test Plans → Configurations**, or at `https://dev.azure.com/<org>/<project>/_apis/test/configurations`.
+
+> While `configurationId` is set, points and results that have no configuration are skipped. Leave it unset for suites that don't use configurations.
+
+### Reusing an existing Test Run
+
+A run is created in `onPrepare` **only** when no run id is available. The id is looked up in this order:
+
+1. the `AZURE_DEVOPS_TEST_RUN_ID` environment variable, then
+2. the `runId` service option.
+
+Both `0` and an unset value mean "create a new run". To publish into a run created elsewhere (e.g. by an earlier pipeline stage):
+
+```bash
+# PowerShell
+$env:AZURE_DEVOPS_TEST_RUN_ID = "12345"; npx wdio run wdio.conf.ts
+
+# bash
+AZURE_DEVOPS_TEST_RUN_ID=12345 npx wdio run wdio.conf.ts
+```
+
+The variable name is exported as a constant so you don't have to hardcode it:
+
+```ts
+import { RUN_ID_ENV_VAR } from "@virag8/azure-devops-test-publisher";
+
+console.log(`Publishing into run ${process.env[RUN_ID_ENV_VAR]}`);
+```
+
+Workers inherit the variable from the launcher process, so it is readable inside specs and hooks. It is cleared again in `onComplete` and does not propagate back to the shell that started WebdriverIO.
+
+### Validating configuration early
+
+`orgUrl`, `projectId`, `planId` and `suiteId` are mandatory. If any is missing or malformed, construction throws `AzureDevOpsConfigError` before a single test runs:
+
+```ts
+import {
+  AzureDevOpsService,
+  AzureDevOpsConfigError,
+} from "@virag8/azure-devops-test-publisher";
+
+try {
+  new AzureDevOpsService(options);
+} catch (err) {
+  if (err instanceof AzureDevOpsConfigError) {
+    console.error("Bad Azure DevOps config:", err.missing); // e.g. ["planId", "suiteId"]
+  }
+}
+```
+
+```
+AzureDevOpsConfigError: Missing or invalid Azure DevOps option(s): planId, suiteId.
+Provide them when constructing the service or in the wdio service options.
+```
+
+A missing `token` is **not** an error — it simply disables publishing with a warning, which keeps local runs working without a PAT.
+
+### Troubleshooting unmatched test cases
+
+When a case id from a title or tag has no matching test point, the exact ids are logged:
+
+```
+No test point found for test case id(s) 9999 in project "MyProject", plan 123, suite 456, configuration 1042.
+The suite exposes 12 point(s) for case id(s) 1001, 1002, … Check that the case ids in your test
+titles belong to this plan/suite and configuration.
+```
+
+Common causes: the case lives in a different suite, the suite id belongs to another plan, or the worker's `configurationId` doesn't match the point's configuration. Set `debug: true` to also dump the raw API payloads.
+
 ## Usage as a standalone reporter
 
 For custom runners that aren't WebdriverIO services, use `AzureDevOpsReporterService` directly:
@@ -95,7 +191,7 @@ import { AzureDevOpsReporterService } from "@virag8/azure-devops-test-publisher"
 const reporter = new AzureDevOpsReporterService({
   orgUrl: process.env.AZURE_ORG_URL!,
   token: process.env.AZURE_PAT!,
-  projectName: "MyProject",
+  projectId: "MyProject",
   planId: 123,
   suiteId: 456,
 });
@@ -118,7 +214,7 @@ import { AzureDevOpsService } from "@virag8/azure-devops-test-publisher";
 const ado = new AzureDevOpsService({
   orgUrl: process.env.AZURE_ORG_URL!,
   token: process.env.AZURE_PAT!,
-  projectName: "MyProject",
+  projectId: "MyProject",
   planId: 123,
   suiteId: 456,
 });
@@ -132,38 +228,62 @@ await ado.publishResults([
 ]);
 ```
 
+Scope a publish to one configuration, and keep the run open for later batches:
+
+```ts
+const runId = await ado.createRun();
+
+await ado.publishResults(
+  [{ testCaseId: 1234, outcome: "Failed", errorMessage: "boom" }],
+  { runId, configurationId: 1042, keepRunOpen: true },
+);
+
+await ado.completeRun(runId);
+```
+
+`createRun()` creates an **empty** run; points are attached by `publishResults` as results come in, so cases that never executed stay out of the run.
+
 ## Configuration reference
 
 ### `AzureDevOpsOptions`
 
-| Option          | Type       | Description                                                         |
-| --------------- | ---------- | ------------------------------------------------------------------- |
-| `orgUrl`        | `string`   | Azure DevOps organization URL.                                      |
-| `token`         | `string`   | Personal access token with Test Plan read/write permissions.        |
-| `projectName`   | `string`   | Azure DevOps project **name or id (GUID)** — both are accepted.     |
-| `planId`        | `number`   | Test plan id.                                                       |
-| `suiteId`       | `number`   | Test suite id within the plan.                                      |
-| `runName`       | `string?`  | Custom name for created runs.                                       |
-| `runId`         | `number?`  | Reuse this existing run instead of creating a new one.              |
-| `reuseTestRun`  | `boolean?` | Keep a single run open across multiple `publishResults` calls.      |
-| `caseIdPattern` | `RegExp?`  | Custom regex (one capturing group) for extracting the test case id. |
-| `debug`         | `boolean?` | Log raw Azure DevOps API payloads. Defaults to `false`.             |
-
-> **Note on `projectName`** — despite the name, this accepts either the project's display name (`"MyProject"`) or its GUID (`"b9e8c7cb-..."`). Prefer the GUID: it stays stable if the project is ever renamed, and it avoids URL-encoding issues with names that contain spaces. You can find it at `https://dev.azure.com/<org>/_apis/projects`.
+| Option          | Type       | Description                                                                          |
+| --------------- | ---------- | ------------------------------------------------------------------------------------ |
+| `orgUrl`        | `string`   | Azure DevOps organization URL.                                                       |
+| `token`         | `string`   | Personal access token with Test Plan read/write permissions.                         |
+| `projectId`     | `string`   | Azure DevOps project **name or id (GUID)** — both are accepted.                      |
+| `planId`        | `number`   | Test plan id.                                                                        |
+| `suiteId`       | `number`   | Test suite id within the plan.                                                       |
+| `runName`       | `string?`  | Custom name for created runs.                                                        |
+| `runId`         | `number?`  | Reuse this existing run instead of creating a new one. `0` means "create a new run". |
+| `reuseTestRun`  | `boolean?` | Keep a single run open across multiple `publishResults` calls.                       |
+| `caseIdPattern` | `RegExp?`  | Custom regex (one capturing group) for extracting the test case id.                  |
+| `debug`         | `boolean?` | Log raw Azure DevOps API payloads. Defaults to `false`.                              |
+
+> **Note on `projectId`** — despite the name, this accepts either the project's display name (`"MyProject"`) or its GUID (`"b9e8c7cb-..."`). Prefer the GUID: it stays stable if the project is ever renamed, and it avoids URL-encoding issues with names that contain spaces. You can find it at `https://dev.azure.com/<org>/_apis/projects`.
 
 ### `AzureDevOpsWdioOptions` (extends `AzureDevOpsOptions`)
 
-| Option                | Type       | Description                                                        |
-| --------------------- | ---------- | ------------------------------------------------------------------ |
-| `screenshotOnFailure` | `boolean?` | Attach a browser screenshot to failed results. Defaults to `true`. |
+| Option                | Type       | Description                                                                                                                                                                                                                                                                            |
+| --------------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `screenshotOnFailure` | `boolean?` | Attach a browser screenshot to failed results. Defaults to `true`.                                                                                                                                                                                                                     |
+| `configurationId`     | `number?`  | Azure DevOps test configuration id for this worker (e.g. Android vs iOS). Set this when the same test case is configured for multiple configurations in your suite, otherwise a result published for one configuration can overwrite another configuration's result for the same case. |
 
 ### `PublishOptions`
 
-| Option        | Type           | Description                                                             |
-| ------------- | -------------- | ----------------------------------------------------------------------- |
-| `runId`       | `number?`      | Publish into this existing run instead of creating a new one.           |
-| `points`      | `TestPoint[]?` | Reuse already-fetched test points instead of calling `getPoints` again. |
-| `keepRunOpen` | `boolean?`     | Leave the run in progress so more results can be added later.           |
+| Option            | Type           | Description                                                                                               |
+| ----------------- | -------------- | --------------------------------------------------------------------------------------------------------- |
+| `runId`           | `number?`      | Publish into this existing run instead of creating a new one. `0` is treated as "not set".                |
+| `points`          | `TestPoint[]?` | Reuse already-fetched test points instead of calling `getPoints` again.                                   |
+| `configurationId` | `number?`      | Only publish to the test point/result of this configuration id; points and results in others are skipped. |
+| `keepRunOpen`     | `boolean?`     | Leave the run in progress so more results can be added later.                                             |
+
+### `AzureDevOpsConfigError`
+
+| Member    | Type       | Description                                             |
+| --------- | ---------- | ------------------------------------------------------- |
+| `missing` | `string[]` | The mandatory option keys that were missing or invalid. |
+| `message` | `string`   | Human readable summary listing every offending key.     |
 
 ## Development
 
@@ -173,6 +293,8 @@ npm run test:real   # integration tests against a real Azure DevOps org (require
 npm run build        # compile to dist/
 ```
 
+`npm run test:real` reads its credentials from a local `.env` file (`AZURE_ORG_URL`, `AZURE_PAT`, `AZURE_PROJECT`, `AZURE_PLAN_ID`, `AZURE_SUITE_ID`, `AZURE_TEST_CASE_ID`) and skips itself when they are absent.
+
 ## License
 
 MIT

package/dist/azureService.d.ts

@@ -1,6 +1,14 @@
 import { AzureDevOpsOptions, PublishOptions, TestResultItem } from "./types";
+/** Thrown when mandatory Azure DevOps options are missing or malformed. */
+export declare class AzureDevOpsConfigError extends Error {
+    readonly missing: string[];
+    constructor(missing: string[]);
+}
+export declare function assertRequiredOptions(config: AzureDevOpsOptions): void;
 export declare class AzureDevOpsService {
     private testApiPromise?;
+    private connection?;
+    private runByPromise?;
     private config;
     private currentRunId?;
     /** Whether a PAT was provided; when false, every public method is a no-op. */
@@ -8,8 +16,12 @@ export declare class AzureDevOpsService {
     constructor(config: AzureDevOpsOptions);
     /** Id of the run currently being published to, if any. */
     get runId(): number | undefined;
+    /** PAT owner, surfaced as "Run by" on the result; Azure leaves the field blank otherwise. */
+    private getRunBy;
     private debug;
-    /** Creates an empty run covering every point of the configured suite. */
+    /** Human readable target used in warnings and errors. */
+    private describeTarget;
+    /** Creates an empty run; points are added by `publishResults` as tests finish, so unexecuted cases are never marked in progress. */
     createRun(): Promise<number | undefined>;
     publishResults(results: TestResultItem[], options?: PublishOptions): Promise<number | undefined>;
     /** Marks a run as completed. Defaults to the run used by the last publish. */

package/dist/azureService.js

@@ -33,15 +33,56 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AzureDevOpsService = void 0;
+exports.AzureDevOpsService = exports.AzureDevOpsConfigError = void 0;
+exports.assertRequiredOptions = assertRequiredOptions;
 const azdev = __importStar(require("azure-devops-node-api"));
+/** True if `point`/`result` belongs to the same test case as `item`, and the same configuration when `item.configurationId` is set. */
+function matchesTestCase(point, item) {
+    if (!point.testCase?.id ||
+        parseInt(point.testCase.id, 10) !== item.testCaseId) {
+        return false;
+    }
+    if (item.configurationId == null)
+        return true;
+    const pointConfigId = point.configuration?.id
+        ? parseInt(point.configuration.id, 10)
+        : undefined;
+    return pointConfigId === item.configurationId;
+}
+/** Thrown when mandatory Azure DevOps options are missing or malformed. */
+class AzureDevOpsConfigError extends Error {
+    missing;
+    constructor(missing) {
+        super(`Missing or invalid Azure DevOps option(s): ${missing.join(", ")}. ` +
+            "Provide them when constructing the service or in the wdio service options.");
+        this.missing = missing;
+        this.name = "AzureDevOpsConfigError";
+    }
+}
+exports.AzureDevOpsConfigError = AzureDevOpsConfigError;
+function assertRequiredOptions(config) {
+    const missing = [];
+    if (!config?.orgUrl?.trim())
+        missing.push("orgUrl");
+    if (!config?.projectId?.toString().trim())
+        missing.push("projectId");
+    if (!Number.isInteger(config?.planId))
+        missing.push("planId");
+    if (!Number.isInteger(config?.suiteId))
+        missing.push("suiteId");
+    if (missing.length > 0)
+        throw new AzureDevOpsConfigError(missing);
+}
 class AzureDevOpsService {
     testApiPromise;
+    connection;
+    runByPromise;
     config;
     currentRunId;
     /** Whether a PAT was provided; when false, every public method is a no-op. */
     enabled;
     constructor(config) {
+        assertRequiredOptions(config);
         this.config = config;
         this.currentRunId = config.runId;
         this.enabled = Boolean(config.token);
@@ -51,39 +92,58 @@ class AzureDevOpsService {
         }
         const authHandler = azdev.getPersonalAccessTokenHandler(config.token);
         const connection = new azdev.WebApi(config.orgUrl, authHandler);
+        this.connection = connection;
         this.testApiPromise = connection.getTestApi();
     }
     /** Id of the run currently being published to, if any. */
     get runId() {
         return this.currentRunId;
     }
+    /** PAT owner, surfaced as "Run by" on the result; Azure leaves the field blank otherwise. */
+    async getRunBy() {
+        try {
+            this.runByPromise ??= this.connection.connect().then((data) => data.authenticatedUser && {
+                id: data.authenticatedUser.id,
+                displayName: data.authenticatedUser.customDisplayName ||
+                    data.authenticatedUser.providerDisplayName,
+            });
+            return await this.runByPromise;
+        }
+        catch (err) {
+            this.debug("Failed to resolve the Run by identity:", err);
+            return undefined;
+        }
+    }
     debug(message, payload) {
         if (!this.config.debug)
             return;
         console.log(message, payload);
     }
-    /** Creates an empty run covering every point of the configured suite. */
+    /** Human readable target used in warnings and errors. */
+    describeTarget(configurationId) {
+        const parts = [
+            `project "${this.config.projectId}"`,
+            `plan ${this.config.planId}`,
+            `suite ${this.config.suiteId}`,
+        ];
+        if (configurationId != null)
+            parts.push(`configuration ${configurationId}`);
+        return parts.join(", ");
+    }
+    /** Creates an empty run; points are added by `publishResults` as tests finish, so unexecuted cases are never marked in progress. */
     async createRun() {
         if (!this.enabled)
             return undefined;
         const testApi = await this.testApiPromise;
-        const points = await testApi.getPoints(this.config.projectName, this.config.planId, this.config.suiteId);
-        const pointIds = points
-            .map((p) => p.id)
-            .filter((id) => typeof id === "number");
-        const configurationIds = Array.from(new Set(points
-            .map((p) => p.configuration?.id ? parseInt(p.configuration.id, 10) : null)
-            .filter((id) => id !== null)));
         const testRun = await testApi.createTestRun({
             name: this.config.runName ||
                 `Automated Test Run - ${new Date().toISOString()}`,
             automated: true,
             plan: { id: this.config.planId.toString() },
-            pointIds,
-            configurationIds,
-        }, this.config.projectName);
+            configurationIds: [],
+        }, this.config.projectId);
         if (!testRun.id) {
-            throw new Error("Failed to create Test Run in Azure DevOps.");
+            throw new Error(`Failed to create Test Run in Azure DevOps for ${this.describeTarget()}; the API returned a run without an id.`);
         }
         this.currentRunId = testRun.id;
         return testRun.id;
@@ -94,15 +154,29 @@ class AzureDevOpsService {
         const testApi = await this.testApiPromise;
         // 1. Get test points matching the local test cases
         const points = options.points ??
-            (await testApi.getPoints(this.config.projectName, this.config.planId, this.config.suiteId));
-        this.debug("Fetched test points:", points);
+            (await testApi.getPoints(this.config.projectId, this.config.planId, this.config.suiteId));
+        this.debug("Fetched test points:", points.length);
+        const inTargetConfiguration = (item) => options.configurationId == null ||
+            (item.configuration?.id != null &&
+                parseInt(item.configuration.id, 10) === options.configurationId);
         const targetCaseIds = new Set(results.map((r) => r.testCaseId));
-        const matchedPoints = points.filter((p) => p.testCase?.id && targetCaseIds.has(parseInt(p.testCase.id, 10)));
+        const matchedPoints = points.filter((p) => p.testCase?.id &&
+            targetCaseIds.has(parseInt(p.testCase.id, 10)) &&
+            inTargetConfiguration(p) &&
+            results.some((r) => matchesTestCase(p, r)));
         this.debug("Matched test points:", matchedPoints);
-        if (matchedPoints.length === 0) {
-            console.warn("No matching test points found in Azure DevOps for the given test cases.");
-            return;
+        const matchedCaseIds = new Set(matchedPoints.map((p) => parseInt(p.testCase.id, 10)));
+        const unmatchedCaseIds = [...targetCaseIds].filter((id) => !matchedCaseIds.has(id));
+        if (unmatchedCaseIds.length > 0) {
+            console.warn(`No test point found for test case id(s) ${unmatchedCaseIds.join(", ")} in ${this.describeTarget(options.configurationId)}. ` +
+                `The suite exposes ${points.length} point(s) for case id(s) ${points
+                    .map((p) => p.testCase?.id)
+                    .filter(Boolean)
+                    .join(", ") || "none"}. ` +
+                "Check that the case ids in your test titles belong to this plan/suite and configuration.");
         }
+        if (matchedPoints.length === 0)
+            return;
         const pointIds = matchedPoints.map((p) => p.id);
         this.debug("Point IDs for the test run:", pointIds);
         // Extract unique configuration IDs from matched points (or fallback to empty array/default)
@@ -117,18 +191,22 @@ class AzureDevOpsService {
         let runId;
         if (reusedRunId) {
             runId = reusedRunId;
-            // Only add points that the run does not already hold a result for
-            const existingResults = await testApi.getTestResults(this.config.projectName, runId);
-            const existingCaseIds = new Set(existingResults.map((r) => r.testCase?.id));
-            const missingPoints = matchedPoints.filter((p) => !existingCaseIds.has(p.testCase.id));
+            // Only add points that the run does not already hold a result for (per case+configuration pair)
+            const existingResults = await testApi.getTestResults(this.config.projectId, runId);
+            const existingPointKeys = new Set(existingResults.map((r) => `${r.testCase?.id}:${r.configuration?.id ?? ""}`));
+            const missingPoints = matchedPoints.filter((p) => !existingPointKeys.has(`${p.testCase?.id}:${p.configuration?.id ?? ""}`));
             if (missingPoints.length > 0) {
-                await testApi.addTestResultsToTestRun(missingPoints.map((p) => ({
+                await testApi.addTestResultsToTestRun(
+                // Planned results are rejected unless point id, case id, revision and title are all present.
+                missingPoints.map((p) => ({
                     testPoint: { id: p.id.toString() },
                     testCase: { id: p.testCase.id },
+                    testCaseRevision: 1,
+                    testCaseTitle: p.testCase?.name || `Test case ${p.testCase.id}`,
                     configuration: p.configuration?.id
                         ? { id: p.configuration.id }
                         : undefined,
-                })), this.config.projectName, runId);
+                })), this.config.projectId, runId);
             }
         }
         else {
@@ -140,49 +218,62 @@ class AzureDevOpsService {
                 plan: { id: this.config.planId.toString() },
                 pointIds: pointIds,
                 configurationIds: configurationIds,
-            }, this.config.projectName);
+            }, this.config.projectId);
             if (!testRun.id) {
-                throw new Error("Failed to create Test Run in Azure DevOps.");
+                throw new Error(`Failed to create Test Run in Azure DevOps for ${this.describeTarget(options.configurationId)} with point id(s) ${pointIds.join(", ")}.`);
             }
             runId = testRun.id;
         }
         this.currentRunId = runId;
         // 3. Fetch automatically created results for the run
-        const runResults = await testApi.getTestResults(this.config.projectName, runId);
+        const runResults = await testApi.getTestResults(this.config.projectId, runId);
         // 4. Map outcomes and error messages
         this.debug("Run results fetched from Azure DevOps:", runResults);
+        const runBy = await this.getRunBy();
         const updatedResults = runResults
-            .filter((result) => results.some((r) => r.testCaseId.toString() === result.testCase?.id))
+            .filter((result) => inTargetConfiguration(result) &&
+            results.some((r) => matchesTestCase(result, r)))
             .map((result) => {
-            const match = results.find((r) => r.testCaseId.toString() === result.testCase?.id);
+            const match = results.find((r) => matchesTestCase(result, r));
             return {
                 ...result,
                 outcome: match ? match.outcome : "Inconclusive",
                 errorMessage: match?.errorMessage || "",
                 state: "Completed",
                 durationInMs: match?.durationInMs || 0,
+                runBy: result.runBy ?? runBy,
             };
         });
         // 5. Update test results in ADO
         this.debug("Updating test results in Azure DevOps:", updatedResults);
-        const savedResults = await testApi.updateTestResults(updatedResults, this.config.projectName, runId);
+        const savedResults = await testApi.updateTestResults(updatedResults, this.config.projectId, runId);
         this.debug("Saved test results:", savedResults);
-        // The real API doesn't always echo `testCase` back on the updated results,
-        // so fall back to the id->caseId mapping we already know from step 4.
-        const caseIdByResultId = new Map();
+        // The real API doesn't always echo `testCase`/`configuration` back on the updated
+        // results, so fall back to what we already know from step 4.
+        const resultInfoById = new Map();
         for (const result of updatedResults) {
-            if (result.id && result.testCase?.id) {
-                caseIdByResultId.set(result.id, result.testCase.id);
+            if (result.id) {
+                resultInfoById.set(result.id, {
+                    caseId: result.testCase?.id,
+                    configurationId: result.configuration?.id,
+                });
             }
         }
         // 6. Upload Attachments
         for (const savedResult of savedResults) {
             if (!savedResult.id)
                 continue;
-            const caseId = savedResult.testCase?.id ?? caseIdByResultId.get(savedResult.id);
+            const info = resultInfoById.get(savedResult.id);
+            const caseId = savedResult.testCase?.id ?? info?.caseId;
             if (!caseId)
                 continue;
-            const matchedLocalResult = results.find((r) => r.testCaseId.toString() === caseId);
+            const configurationId = savedResult.configuration?.id ?? info?.configurationId;
+            const matchedLocalResult = results.find((r) => matchesTestCase({
+                testCase: { id: caseId },
+                configuration: configurationId
+                    ? { id: configurationId }
+                    : undefined,
+            }, r));
             if (matchedLocalResult?.attachments &&
                 matchedLocalResult.attachments.length > 0) {
                 for (const attachment of matchedLocalResult.attachments) {
@@ -200,7 +291,7 @@ class AzureDevOpsService {
                         attachmentType: attachmentModel.attachmentType,
                         base64Length: attachment.base64Content?.length ?? 0,
                     });
-                    const savedAttachment = await testApi.createTestResultAttachment(attachmentModel, this.config.projectName, runId, savedResult.id);
+                    const savedAttachment = await testApi.createTestResultAttachment(attachmentModel, this.config.projectId, runId, savedResult.id);
                     this.debug("Attachment uploaded:", savedAttachment);
                 }
             }
@@ -220,7 +311,7 @@ class AzureDevOpsService {
         if (!this.enabled || !runId)
             return;
         const testApi = await this.testApiPromise;
-        await testApi.updateTestRun({ state: "Completed" }, this.config.projectName, runId);
+        await testApi.updateTestRun({ state: "Completed" }, this.config.projectId, runId);
         if (runId === this.currentRunId) {
             this.currentRunId = undefined;
         }

package/dist/index.js

@@ -22,6 +22,7 @@ class AzureDevOpsReporterService {
     results = [];
     ado;
     constructor(options) {
+        (0, azureService_1.assertRequiredOptions)(options);
         this.options = options;
     }
     async afterTest(test, _context, results, browserInstance) {
@@ -50,6 +51,7 @@ class AzureDevOpsReporterService {
             errorMessage: results.error?.message,
             durationInMs: test.duration,
             attachments,
+            configurationId: this.options.configurationId,
         });
     }
     async onComplete() {

package/dist/types.d.ts

@@ -3,7 +3,7 @@ export interface AzureDevOpsOptions {
     orgUrl: string;
     token: string;
     /** Project display name or its GUID; Azure DevOps accepts either. */
-    projectName: string;
+    projectId: string;
     planId: number;
     suiteId: number;
     runName?: string;
@@ -21,12 +21,16 @@ export interface PublishOptions {
     runId?: number;
     /** Reuse already-fetched test points instead of calling `getPoints` again. */
     points?: TestPoint[];
+    /** Only publish to the test point/result of this Azure DevOps configuration id; others are left untouched. */
+    configurationId?: number;
     /** Leave the run in progress so more results can be added later. */
     keepRunOpen?: boolean;
 }
 export interface AzureDevOpsWdioOptions extends AzureDevOpsOptions {
     /** Attach a browser screenshot to failed results. Defaults to true. */
     screenshotOnFailure?: boolean;
+    /** Azure DevOps test configuration id (e.g. Android vs iOS) this worker's results belong to. Required when the same test case is configured for multiple configurations, otherwise results can bleed across configurations. */
+    configurationId?: number;
 }
 export interface TestAttachment {
     fileName: string;
@@ -40,4 +44,6 @@ export interface TestResultItem {
     errorMessage?: string;
     durationInMs?: number;
     attachments?: TestAttachment[];
+    /** Azure DevOps test configuration id; disambiguates test points/results that share a case id across configurations (e.g. Android vs iOS). */
+    configurationId?: number;
 }

package/dist/wdioService.d.ts

@@ -1,15 +1,9 @@
+import type { Frameworks, Services } from "@wdio/types" with {
+    "resolution-mode": "import"
+};
 import { AzureDevOpsWdioOptions } from "./types";
 /** Shares the run id created in the launcher process with the worker processes. */
 export declare const RUN_ID_ENV_VAR = "AZURE_DEVOPS_TEST_RUN_ID";
-interface WdioTest {
-    title: string;
-    fullTitle?: string;
-}
-interface WdioTestResult {
-    passed: boolean;
-    duration?: number;
-    error?: Error;
-}
 interface CucumberPickleTag {
     name: string;
 }
@@ -20,34 +14,30 @@ interface CucumberWorld {
         tags?: CucumberPickleTag[];
     };
 }
-interface CucumberResult {
-    passed: boolean;
-    duration?: number;
-    error?: Error;
-}
 /**
  * WebdriverIO service that creates a single Test Run in `onPrepare`, pushes every
  * spec's results into that run, and completes it in `onComplete`.
  */
-export declare class AzureDevOpsWdioService {
-    private options;
+export default class AzureDevOpsWdioService implements Services.ServiceInstance {
+    private readonly _options;
     private results;
     private service?;
-    constructor(options: AzureDevOpsWdioOptions);
+    constructor(_options: AzureDevOpsWdioOptions);
     onPrepare(): Promise<void>;
     onComplete(): Promise<void>;
     private debug;
-    afterTest(test: WdioTest, _context: unknown, results: WdioTestResult): Promise<void>;
+    afterTest(test: Frameworks.Test, _context: unknown, results: Frameworks.TestResult): Promise<void>;
     /** Cucumber hook for BDD feature files; reads the case id from a `@C123` tag or the scenario name. */
-    afterScenario(world: CucumberWorld, result: CucumberResult): Promise<void>;
+    afterScenario(world: CucumberWorld, result: Frameworks.PickleResult): Promise<void>;
+    /** Cucumber's `error` is typed as a string, but some frameworks still pass a raw `Error`. */
+    private stringifyError;
     after(): Promise<void>;
     /** Publishes everything collected so far into the shared run. */
     publish(): Promise<void>;
     private captureScreenshot;
     private extractCucumberCaseId;
+    /** `0` is treated as "not set", so a fresh run gets created. */
     private resolveRunId;
     private getService;
 }
-/** WebdriverIO looks for a `launcher` export to run `onPrepare`/`onComplete`. */
-export declare const launcher: typeof AzureDevOpsWdioService;
-export default AzureDevOpsWdioService;
+export { AzureDevOpsWdioService };

package/dist/wdioService.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.launcher = exports.AzureDevOpsWdioService = exports.RUN_ID_ENV_VAR = void 0;
+exports.AzureDevOpsWdioService = exports.RUN_ID_ENV_VAR = void 0;
 const azureService_1 = require("./azureService");
 const utils_1 = require("./utils");
 /** Shares the run id created in the launcher process with the worker processes. */
@@ -10,14 +10,21 @@ exports.RUN_ID_ENV_VAR = "AZURE_DEVOPS_TEST_RUN_ID";
  * spec's results into that run, and completes it in `onComplete`.
  */
 class AzureDevOpsWdioService {
-    options;
+    _options;
     results = [];
     service;
-    constructor(options) {
-        this.options = options;
+    constructor(_options) {
+        this._options = _options;
+        (0, azureService_1.assertRequiredOptions)(_options);
     }
     // --- launcher process hooks ---
     async onPrepare() {
+        const existingRunId = this.resolveRunId();
+        if (existingRunId) {
+            process.env[exports.RUN_ID_ENV_VAR] = existingRunId.toString();
+            console.log(`Reusing Azure DevOps test run: ${existingRunId}`);
+            return;
+        }
         const runId = await this.getService().createRun();
         if (runId === undefined)
             return;
@@ -34,15 +41,15 @@ class AzureDevOpsWdioService {
     }
     // --- worker process hooks ---
     debug(message, payload) {
-        if (!this.options.debug)
+        if (!this._options.debug)
             return;
         console.log(message, payload);
     }
     async afterTest(test, _context, results) {
-        const caseId = (0, utils_1.extractTestCaseId)(test.title, this.options.caseIdPattern);
+        const caseId = (0, utils_1.extractTestCaseId)(test.title, this._options.caseIdPattern);
         this.debug("Extracted case id from test title:", {
             title: test.title,
-            pattern: String(this.options.caseIdPattern ?? "default C123/#123"),
+            pattern: String(this._options.caseIdPattern ?? "default C123/#123"),
             caseId,
         });
         if (!caseId)
@@ -53,6 +60,7 @@ class AzureDevOpsWdioService {
             errorMessage: results.error?.message,
             durationInMs: results.duration ?? 0,
             attachments: await this.captureScreenshot(caseId, test, results),
+            configurationId: this._options.configurationId,
         });
     }
     /** Cucumber hook for BDD feature files; reads the case id from a `@C123` tag or the scenario name. */
@@ -63,11 +71,18 @@ class AzureDevOpsWdioService {
         this.results.push({
             testCaseId: caseId,
             outcome: result.passed ? "Passed" : "Failed",
-            errorMessage: result.error?.message,
+            errorMessage: this.stringifyError(result.error),
             durationInMs: result.duration ?? 0,
             attachments: await this.captureScreenshot(caseId, { title: world.pickle.name }, result),
+            configurationId: this._options.configurationId,
         });
     }
+    /** Cucumber's `error` is typed as a string, but some frameworks still pass a raw `Error`. */
+    stringifyError(error) {
+        if (!error)
+            return undefined;
+        return error instanceof Error ? error.message : String(error);
+    }
     async after() {
         await this.publish();
     }
@@ -81,6 +96,7 @@ class AzureDevOpsWdioService {
             await this.getService().publishResults(pending, {
                 runId: this.resolveRunId(),
                 keepRunOpen: true,
+                configurationId: this._options.configurationId,
             });
         }
         catch (err) {
@@ -88,7 +104,7 @@ class AzureDevOpsWdioService {
         }
     }
     async captureScreenshot(caseId, test, results) {
-        if (results.passed || this.options.screenshotOnFailure === false)
+        if (results.passed || this._options.screenshotOnFailure === false)
             return [];
         const browser = globalThis
             .browser;
@@ -109,7 +125,7 @@ class AzureDevOpsWdioService {
         }
     }
     extractCucumberCaseId(world) {
-        const pattern = this.options.caseIdPattern;
+        const pattern = this._options.caseIdPattern;
         const tags = world.pickle.tags ?? [];
         this.debug("Scanning scenario tags for case id:", {
             scenario: world.pickle.name,
@@ -130,17 +146,17 @@ class AzureDevOpsWdioService {
         });
         return fromName;
     }
+    /** `0` is treated as "not set", so a fresh run gets created. */
     resolveRunId() {
         const fromEnv = process.env[exports.RUN_ID_ENV_VAR];
         const parsed = fromEnv ? parseInt(fromEnv, 10) : NaN;
-        return Number.isNaN(parsed) ? this.options.runId : parsed;
+        const runId = Number.isNaN(parsed) ? this._options.runId : parsed;
+        return runId || undefined;
     }
     getService() {
-        this.service ??= new azureService_1.AzureDevOpsService(this.options);
+        this.service ??= new azureService_1.AzureDevOpsService(this._options);
         return this.service;
     }
 }
-exports.AzureDevOpsWdioService = AzureDevOpsWdioService;
-/** WebdriverIO looks for a `launcher` export to run `onPrepare`/`onComplete`. */
-exports.launcher = AzureDevOpsWdioService;
 exports.default = AzureDevOpsWdioService;
+exports.AzureDevOpsWdioService = AzureDevOpsWdioService;

package/package.json

@@ -1,62 +1,64 @@
-{
-  "name": "@virag8/azure-devops-test-publisher",
-  "version": "1.0.1",
-  "description": "Upload test results and screenshots to Azure DevOps Test Plans from WebdriverIO or custom TS runners",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "license": "MIT",
-  "author": "virag <viragkumar58@gmail.com>",
-  "homepage": "https://github.com/viragkumar/azure-devops-test-publisher#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/viragkumar/azure-devops-test-publisher.git"
-  },
-  "bugs": {
-    "url": "https://github.com/viragkumar/azure-devops-test-publisher/issues"
-  },
-  "keywords": [
-    "webdriverio",
-    "wdio",
-    "wdio-service",
-    "ado",
-    "azure-devops",
-    "azure-test-plans",
-    "test-results",
-    "reporter",
-    "cucumber",
-    "mocha",
-    "typescript",
-    "azure-devops-test-publisher",
-    "test-publisher"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "rimraf dist && tsc",
-    "prepublishOnly": "npm run test:unit && npm run build",
-    "test:unit": "jest --config tests/jest.config.js",
-    "test:real": "jest --config tests/jest.real.config.js",
-    "test": "npm run test:unit"
-  },
-  "dependencies": {
-    "azure-devops-node-api": "^12.0.0"
-  },
-  "devDependencies": {
-    "@types/jest": "^30.0.0",
-    "@types/node": "^20.0.0",
-    "dotenv": "^17.4.2",
-    "jest": "^30.5.1",
-    "rimraf": "^5.0.0",
-    "ts-jest": "^29.4.12",
-    "typescript": "^5.0.0"
-  }
-}
+{
+  "name": "@virag8/azure-devops-test-publisher",
+  "version": "1.2.2",
+  "description": "Upload test results and screenshots to Azure DevOps Test Plans from WebdriverIO or custom TS runners",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "author": "virag <viragkumar58@gmail.com>",
+  "homepage": "https://github.com/viragkumar/azure-devops-test-publisher#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/viragkumar/azure-devops-test-publisher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/viragkumar/azure-devops-test-publisher/issues"
+  },
+  "keywords": [
+    "webdriverio",
+    "wdio",
+    "wdio-service",
+    "ado",
+    "azure-devops",
+    "azure-test-plans",
+    "test-results",
+    "reporter",
+    "cucumber",
+    "mocha",
+    "typescript",
+    "azure-devops-test-publisher",
+    "test-publisher"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "prepublishOnly": "npm run test:unit && npm run build",
+    "test:unit": "jest --config tests/jest.config.js",
+    "test:real": "jest --config tests/jest.real.config.js",
+    "test": "npm run test:unit",
+    "pack:local": "npm run build && npm pack"
+  },
+  "dependencies": {
+    "azure-devops-node-api": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "@wdio/types": "^9.31.2",
+    "dotenv": "^17.4.2",
+    "jest": "^30.5.1",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.0.0"
+  }
+}