@allurereport/plugin-testops 3.21.0 → 3.22.0

package/README.md

@@ -77,7 +77,7 @@ The plugin accepts the following options:
 | `accessToken`      | Access token for Allure TestOps API                                        | `string`  | `undefined`     |
 | `endpoint`         | Allure TestOps API endpoint                                                | `string`  | `undefined`     |
 | `projectId`        | Allure TestOps project ID                                                  | `string`  | `undefined`     |
-| `autocloseLaunch`  | When `true` (default), the launch is closed automatically when the plugin finishes; set to `false` to keep the launch open | `boolean` | `true`          |
+| `autocloseLaunch`  | When `true` (default), the launch is closed automatically when the plugin finishes, unless some uploads failed; set to `false` to keep the launch open | `boolean` | `true`          |
 | `gitFlow`          | When `true`, collect Git metadata for Allure TestOps Git Flow on CI uploads (opt-in) | `boolean` | `false`         |
 | `ancestorLimit`    | How many ancestor commits to attach to the launch for history linking in Allure TestOps | `number`  | `100`           |
 | `uploadRateLimit`  | Caps how fast uploads are sent to Allure TestOps within a rolling time window (requests/files/bytes per window); pass `false` to disable pacing entirely | `{ windowMs: number; maxRequestsPerWindow?: number; maxFilesPerWindow?: number; maxBytesPerWindow?: number } \| false` | `20` req/s, `1000` files/s, `1 GiB`/s |
@@ -97,4 +97,47 @@ The plugin automatically reads the following environment variables and uses them
 | `ALLURE_GIT_FLOW` | `gitFlow` |
 | `ALLURE_GIT_ANCESTOR_LIMIT` | `ancestorLimit` |
 
-`ALLURE_TESTOPS_ENABLED` and `CI` are not configuration options: they only control whether upload runs when no CI is detected. See [CI and local runs](#ci-and-local-runs).
+`ALLURE_TESTOPS_ENABLED` and `CI` are not configuration options: they only control whether upload runs when no CI is detected. See [CI and local runs](#ci-and-local-runs).
+
+## Environment variables
+
+Every upload session sends environment variables to Allure TestOps, which maps them to the project's env vars. A variable shows up on test results only if its key matches a key of the project's env var schema in Allure TestOps exactly, including case: a schema key `browser` does not match a variable named `Browser`. Other keys are ignored.
+
+The plugin sends, from weakest to strongest:
+
+1. the environment variables of the process (for example, the ones set by your CI);
+2. the report-level `variables` from the Allure configuration;
+3. the `variables` of the environment (from `environments`) the test result belongs to.
+
+A stronger source overrides a weaker one when the keys are the same. Keys that differ only in case are different variables and are all sent. Configuration variables without a value (for example, `process.env.STAND` when `STAND` is unset, or an empty string) and values that aren't strings, numbers or booleans are not sent, so they don't override anything: an environment variable without a value keeps the report-level value.
+
+```js
+import { defineConfig } from "allure";
+
+export default defineConfig({
+  variables: {
+    Stand: process.env.STAND ?? "staging",
+  },
+  environments: {
+    chrome: {
+      matcher: ({ labels }) => labels.some(({ name, value }) => name === "browser" && value === "chrome"),
+      variables: { browser: "chrome" },
+    },
+    firefox: {
+      matcher: ({ labels }) => labels.some(({ name, value }) => name === "browser" && value === "firefox"),
+      variables: { browser: "firefox" },
+    },
+  },
+  plugins: {
+    testops: {
+      options: {},
+    },
+  },
+});
+```
+
+Test results of an environment that defines its own `variables` are uploaded in a separate upload session carrying those variables; the plugin creates it once per environment and reuses it for the whole run. Other test results go into the upload session the plugin creates for each upload, together with global attachments and errors.
+
+Report-level `variables` are the same for every test result. When a report is generated from several dumps (`allure generate --dump …`), they are merged and the last dump wins. Environment `variables` come from the configuration used to generate the report, so values that differ between dumps, such as the browser of a matrix job, belong in the `variables` of environments defined in that configuration rather than in report-level `variables`.
+
+Env vars are part of a test result's identity in Allure TestOps. If your project's env var schema contains keys that you now set in `variables`, the history of the affected tests starts anew once after upgrading the plugin.

package/dist/client.d.ts

@@ -4,7 +4,7 @@ import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import { AxiosError, type AxiosResponse } from "axios";
 import type { RetryOptions } from "./errors.js";
 import type { LaunchGitContextDto } from "./gitFlow/index.js";
-import type { AttachmentForUpload, AttachmentsResolver, FixtureResolver, LaunchCategoryBulkItem, LaunchCategoryBulkResult, TestOpsClientParams, TestOpsNamedEnv, TestOpsPluginTestResult } from "./model.js";
+import type { AttachmentForUpload, AttachmentsResolver, FixtureResolver, LaunchCategoryBulkItem, LaunchCategoryBulkResult, TestOpsClientParams, TestOpsNamedEnv, TestOpsPluginTestResult, TestOpsSession } from "./model.js";
 declare class TestOpsClientError extends AxiosError<{
     message: string;
     timestamp: number;
@@ -31,7 +31,9 @@ export declare class TestOpsClient {
     createLaunch(launchName: string, launchTags: string[], gitContext?: LaunchGitContextDto): Promise<void>;
     attachToLaunch(launchId: number): void;
     checkLaunchProgress(): Promise<boolean>;
-    createSession(environment?: Record<string, unknown>, reopenClosedLaunch?: boolean): Promise<void>;
+    ensureLaunchOpen(reopenClosedLaunch?: boolean): Promise<void>;
+    createSession(environment?: Record<string, unknown>, reopenClosedLaunch?: boolean): Promise<TestOpsSession>;
+    createSessionInOpenLaunch(environment?: Record<string, unknown>): Promise<TestOpsSession>;
     getNamedEnvFor(id: string): TestOpsNamedEnv | undefined;
     createNamedEnvs(environments: EnvironmentIdentity[], onProgress?: (percent: number, total: number) => void): Promise<void>;
     uploadGlobalAttachments(params: {
@@ -48,6 +50,7 @@ export declare class TestOpsClient {
         onProgress?: () => void;
         onRetry?: RetryOptions["onRetry"];
         onChunkUploaded?: (uploadedChunkTrs: TestResult[]) => void;
+        session: TestOpsSession;
     }): Promise<TestResult[]>;
     uploadQualityGateResults(results: QualityGateValidationResult[], onProgress?: (percent: number, total: number) => void): Promise<void>;
 }

package/dist/client.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TestOpsClient_instances, _TestOpsClient_baseUrl, _TestOpsClient_logger, _TestOpsClient_accessToken, _TestOpsClient_projectId, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_jobRunId, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit, _TestOpsClient_uploadPacer, _TestOpsClient_namedEnvsIdsByEnv, _TestOpsClient_getExistingJob, _TestOpsClient_postTestResultsChunk, _TestOpsClient_uploadChunkAttachmentsAndFixtures, _TestOpsClient_uploadAttachmentsForResult, _TestOpsClient_logResultUploadFailure, _TestOpsClient_uploadFixturesForResult;
+var _TestOpsClient_instances, _TestOpsClient_baseUrl, _TestOpsClient_logger, _TestOpsClient_accessToken, _TestOpsClient_projectId, _TestOpsClient_client, _TestOpsClient_launch, _TestOpsClient_jobRunId, _TestOpsClient_session, _TestOpsClient_uploadInProgress, _TestOpsClient_uploadLimit, _TestOpsClient_uploadPacer, _TestOpsClient_namedEnvsIdsByEnv, _TestOpsClient_getExistingJob, _TestOpsClient_namedEnvByIdOrName, _TestOpsClient_postTestResultsChunk, _TestOpsClient_uploadChunkAttachmentsAndFixtures, _TestOpsClient_uploadAttachmentsForResult, _TestOpsClient_logResultUploadFailure, _TestOpsClient_uploadFixturesForResult;
 import { isLocalCiDescriptor } from "@allurereport/ci";
 import { KnownError, createServiceHttpClient } from "@allurereport/service";
 import { AxiosError, isAxiosError } from "axios";
@@ -221,7 +221,7 @@ export class TestOpsClient {
         const data = await retryRequest(() => __classPrivateFieldGet(this, _TestOpsClient_client, "f").get(`/api/launch/${__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id}/progress`));
         return data.ready;
     }
-    async createSession(environment = {}, reopenClosedLaunch = false) {
+    async ensureLaunchOpen(reopenClosedLaunch = false) {
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
@@ -232,6 +232,15 @@ export class TestOpsClient {
             }
             await this.reopenLaunch(__classPrivateFieldGet(this, _TestOpsClient_launch, "f").id);
         }
+    }
+    async createSession(environment = {}, reopenClosedLaunch = false) {
+        await this.ensureLaunchOpen(reopenClosedLaunch);
+        return this.createSessionInOpenLaunch(environment);
+    }
+    async createSessionInOpenLaunch(environment = {}) {
+        if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
+            throw new Error("Launch isn't created! Call createLaunch first");
+        }
         const sessionEnvironment = Object.entries(environment).map(([key, value]) => ({
             key,
             value: String(value),
@@ -245,6 +254,7 @@ export class TestOpsClient {
                 params: { manual: "true" },
             });
         __classPrivateFieldSet(this, _TestOpsClient_session, data, "f");
+        return data;
     }
     getNamedEnvFor(id) {
         return __classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").get(id);
@@ -343,10 +353,7 @@ export class TestOpsClient {
         });
     }
     async uploadTestResults(params) {
-        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
-            throw new Error("Session isn't created! Call createSession first");
-        }
-        const { trs, environments, attachmentsResolver, fixturesResolver, onProgress, onRetry, onChunkUploaded } = params;
+        const { session, trs, environments, attachmentsResolver, fixturesResolver, onProgress, onRetry, onChunkUploaded } = params;
         const projectedTrs = trs.map((tr) => ({
             ...tr,
             ...(tr.steps ? { steps: normalizeTestStepsResults(tr.steps) } : {}),
@@ -372,7 +379,7 @@ export class TestOpsClient {
                     await this.createNamedEnvs(envsToCreate);
                 }
                 await __classPrivateFieldGet(this, _TestOpsClient_uploadPacer, "f").wait({ requests: 1, files: trsChunk.length });
-                return __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_postTestResultsChunk).call(this, trsChunk);
+                return __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_postTestResultsChunk).call(this, trsChunk, session);
             }, { onRetry });
             const uploadedChunkTrs = trsChunk.filter((tr) => typeof reportIdsToTestOpsIds[tr.id] === "number");
             uploadedTrs.push(...uploadedChunkTrs);
@@ -383,9 +390,6 @@ export class TestOpsClient {
         return uploadedTrs;
     }
     async uploadQualityGateResults(results, onProgress) {
-        if (!__classPrivateFieldGet(this, _TestOpsClient_session, "f")) {
-            throw new Error("Session isn't created! Call createSession first");
-        }
         if (!__classPrivateFieldGet(this, _TestOpsClient_launch, "f")) {
             throw new Error("Launch isn't created! Call createLaunch first");
         }
@@ -395,7 +399,7 @@ export class TestOpsClient {
                 name: result.rule,
                 message: result.message,
             };
-            const namedEnvId = !!result.environment && this.getNamedEnvFor(result.environment)?.id;
+            const namedEnvId = !!result.environment && __classPrivateFieldGet(this, _TestOpsClient_instances, "m", _TestOpsClient_namedEnvByIdOrName).call(this, result.environment)?.id;
             if (typeof namedEnvId === "number") {
                 item.namedEnvId = namedEnvId;
             }
@@ -427,7 +431,10 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
         }
         throw error;
     }
-}, _TestOpsClient_postTestResultsChunk = async function _TestOpsClient_postTestResultsChunk(trsChunk) {
+}, _TestOpsClient_namedEnvByIdOrName = function _TestOpsClient_namedEnvByIdOrName(environment) {
+    return (__classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").get(environment) ??
+        [...__classPrivateFieldGet(this, _TestOpsClient_namedEnvsIdsByEnv, "f").values()].find(({ name }) => name === environment));
+}, _TestOpsClient_postTestResultsChunk = async function _TestOpsClient_postTestResultsChunk(trsChunk, session) {
     const extendedChunk = trsChunk.map((testResult) => {
         const extendedTestResult = {
             ...testResult,
@@ -446,7 +453,7 @@ _TestOpsClient_baseUrl = new WeakMap(), _TestOpsClient_logger = new WeakMap(), _
         }
         return extendedTestResult;
     });
-    const body = toUploadResultsDto(__classPrivateFieldGet(this, _TestOpsClient_session, "f").id, extendedChunk);
+    const body = toUploadResultsDto(session.id, extendedChunk);
     const data = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/upload/test-result", {
         body,
         headers: { "Content-Type": "application/json" },

package/dist/model.d.ts

@@ -212,7 +212,6 @@ export type TestOpsUploaderOptions = {
 export interface TestOpsFixtureResult extends Omit<TestFixtureResult, "type"> {
     type: "BEFORE" | "AFTER";
 }
-export type TemplateManifest = Record<string, string>;
 export type TestOpsPluginOptions = TestOpsUploaderOptions;
 export type TestOpsSession = {
     id: number;

package/dist/plugin.js

@@ -9,13 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_uploadedGlobalAttachmentIds, _TestOpsPlugin_uploadedGlobalErrors, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_launchStarted, _TestOpsPlugin_reopenClosedLaunch, _TestOpsPlugin_skippedUploadCycle, _TestOpsPlugin_launchId, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQueue, _TestOpsPlugin_reopenLaunchIfClosed, _TestOpsPlugin_logDeferredUpload, _TestOpsPlugin_retryHooks, _TestOpsPlugin_logUploadFailure, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
+var _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_uploadedGlobalAttachmentIds, _TestOpsPlugin_uploadedGlobalErrors, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_launchStarted, _TestOpsPlugin_reopenClosedLaunch, _TestOpsPlugin_skippedUploadCycle, _TestOpsPlugin_environmentSessions, _TestOpsPlugin_launchId, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQueue, _TestOpsPlugin_reopenLaunchIfClosed, _TestOpsPlugin_logDeferredUpload, _TestOpsPlugin_retryHooks, _TestOpsPlugin_logUploadFailure, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_environmentSession, _TestOpsPlugin_upload, _TestOpsPlugin_groupByEnvironmentVariables, _TestOpsPlugin_environmentIdOf, _TestOpsPlugin_environmentVariables, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
 import { env } from "node:process";
 import { applyAllureCiEnv, detect, isLocalCiDescriptor } from "@allurereport/ci";
 import { createProgressLogger, getGlobalLogLevel } from "@allurereport/cli-commons";
-import { getWorstStatus } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, getWorstStatus } from "@allurereport/core-api";
 import { createPluginSummary, } from "@allurereport/plugin-api";
-import { uniqBy, stubTrue } from "lodash-es";
+import { groupBy, isEqual, uniqBy, stubTrue } from "lodash-es";
 import { bold } from "yoctocolors";
 import { TestOpsClient } from "./client.js";
 import { isClosedLaunchError } from "./errors.js";
@@ -27,6 +27,7 @@ import { applyCiOverrides } from "./utils/ciOverrides.js";
 import { enrichWithCategories, syncLaunchCategories } from "./utils/launchCategories.js";
 import { resolvePluginOptions, toPositiveInteger } from "./utils/options.js";
 import { attachmentsResolverFactory, fixturesResolverFactory } from "./utils/resolvers.js";
+import { toSessionVariables } from "./utils/sessionEnvironment.js";
 import { validateExecutableName } from "./utils/validation.js";
 const LAUNCH_PROGRESS_POLL_DELAY_MS = 500;
 const LAUNCH_PROGRESS_ATTEMPTS_LIMIT = 10;
@@ -47,6 +48,7 @@ export class TestOpsPlugin {
         _TestOpsPlugin_launchStarted.set(this, false);
         _TestOpsPlugin_reopenClosedLaunch.set(this, false);
         _TestOpsPlugin_skippedUploadCycle.set(this, false);
+        _TestOpsPlugin_environmentSessions.set(this, new Map());
         _TestOpsPlugin_launchId.set(this, void 0);
         _TestOpsPlugin_gitFlow.set(this, void 0);
         _TestOpsPlugin_enabledByConfig.set(this, false);
@@ -188,7 +190,11 @@ export class TestOpsPlugin {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Upload finished. Allure TestOps Launch: ${__classPrivateFieldGet(this, _TestOpsPlugin_client, "f").launchUrl}`);
             return;
         }
-        if (stillPending.length > 0 || __classPrivateFieldGet(this, _TestOpsPlugin_skippedUploadCycle, "f")) {
+        const failedUploads = __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").failedNames;
+        if (failedUploads.length > 0) {
+            __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").error(`${failedUploads.length} TestOps upload(s) failed: ${failedUploads.join(", ")}`);
+        }
+        if (stillPending.length > 0 || failedUploads.length > 0 || __classPrivateFieldGet(this, _TestOpsPlugin_skippedUploadCycle, "f")) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Not closing launch ${launchId}: some uploads never made it to TestOps, closing now would report an incomplete launch as finished.`);
             return;
         }
@@ -239,7 +245,7 @@ export class TestOpsPlugin {
         return summary;
     }
 }
-_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalAttachmentIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalErrors = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_launchStarted = new WeakMap(), _TestOpsPlugin_reopenClosedLaunch = new WeakMap(), _TestOpsPlugin_skippedUploadCycle = new WeakMap(), _TestOpsPlugin_launchId = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_uploadQueue = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_reopenLaunchIfClosed = async function _TestOpsPlugin_reopenLaunchIfClosed(error) {
+_TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestOpsPlugin_client = new WeakMap(), _TestOpsPlugin_launchName = new WeakMap(), _TestOpsPlugin_launchTags = new WeakMap(), _TestOpsPlugin_uploadedTestResultsIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalAttachmentIds = new WeakMap(), _TestOpsPlugin_uploadedGlobalErrors = new WeakMap(), _TestOpsPlugin_autocloseLaunch = new WeakMap(), _TestOpsPlugin_launchStarted = new WeakMap(), _TestOpsPlugin_reopenClosedLaunch = new WeakMap(), _TestOpsPlugin_skippedUploadCycle = new WeakMap(), _TestOpsPlugin_environmentSessions = new WeakMap(), _TestOpsPlugin_launchId = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_uploadQueue = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_reopenLaunchIfClosed = async function _TestOpsPlugin_reopenLaunchIfClosed(error) {
     if (!__classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f") || !isClosedLaunchError(error)) {
         return;
     }
@@ -406,18 +412,21 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     }
 }, _TestOpsPlugin_uploadTestResults = async function _TestOpsPlugin_uploadTestResults(store, trsToUpload, environments, options) {
     const totalCount = trsToUpload.length;
-    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose(`Preparing to upload ${bold(totalCount.toString())} ${totalCount > 1 ? "test results" : "test result"}`);
+    const forEnvironment = options.environmentName ? ` for environment ${options.environmentName}` : "";
+    const label = `test results${forEnvironment}`;
+    __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose(`Preparing to upload ${bold(totalCount.toString())} ${totalCount > 1 ? "test results" : "test result"}${forEnvironment}`);
     const progressLogger = createProgressLogger({
         total: totalCount,
-        message: "Uploading test results",
+        message: `Uploading ${label}`,
         unitLabel: totalCount === 1 ? "test result uploaded" : "test results uploaded",
         prefix: "[TestOpsPlugin]",
-        silent: !!options?.silent,
+        silent: !!options.silent,
     });
     try {
         progressLogger.log(true);
-        const { onRetry, onDeferred } = __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, "test results");
-        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run("test-results", () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
+        const { onRetry, onDeferred } = __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_retryHooks).call(this, label);
+        const result = await __classPrivateFieldGet(this, _TestOpsPlugin_uploadQueue, "f").run(options.queueName, async () => __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").uploadTestResults({
+            session: await options.session(),
             attachmentsResolver: attachmentsResolverFactory(store),
             fixturesResolver: fixturesResolverFactory(store),
             environments,
@@ -441,14 +450,22 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose("No test results were uploaded");
             return;
         }
-        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Uploaded ${uploadedCount} ${uploadedCount > 1 ? "test results" : "test result"}`);
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`Uploaded ${uploadedCount} ${uploadedCount > 1 ? "test results" : "test result"}${forEnvironment}`);
     }
     catch (error) {
-        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, "test results", error);
+        __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_logUploadFailure).call(this, label, error);
     }
     finally {
         progressLogger.cancel?.();
     }
+}, _TestOpsPlugin_environmentSession = async function _TestOpsPlugin_environmentSession(environmentId, environmentVariables) {
+    const cached = __classPrivateFieldGet(this, _TestOpsPlugin_environmentSessions, "f").get(environmentId);
+    if (cached) {
+        return cached;
+    }
+    const session = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSessionInOpenLaunch({ ...env, ...environmentVariables });
+    __classPrivateFieldGet(this, _TestOpsPlugin_environmentSessions, "f").set(environmentId, session);
+    return session;
 }, _TestOpsPlugin_upload = async function _TestOpsPlugin_upload(store, options = {}) {
     const { context, stage } = options;
     const trsToUpload = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_trsToUpload).call(this, store);
@@ -477,8 +494,19 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     if (stage === "update" && trsToUpload.length > 0) {
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").verbose(`Found ${bold(trsToUpload.length.toString())} new test ${trsToUpload.length > 1 ? "results" : "result"}, uploading…`);
     }
+    const environments = await store.allEnvironmentIdentities();
+    const contextCategories = context?.categories ?? [];
+    const trsEnrichedWithCategories = await enrichWithCategories(store, trsToUpload, contextCategories, (environment) => __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_environmentIdOf).call(this, environment, environments));
+    const groups = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_groupByEnvironmentVariables).call(this, store, trsEnrichedWithCategories);
+    const needsBaseSession = globalErrors.length > 0 || globalAttachments.length > 0 || groups.base.length > 0;
+    let baseSession;
     try {
-        await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession(env, __classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f"));
+        if (needsBaseSession) {
+            baseSession = await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createSession({ ...env, ...groups.reportVariables }, __classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f"));
+        }
+        else {
+            await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").ensureLaunchOpen(__classPrivateFieldGet(this, _TestOpsPlugin_reopenClosedLaunch, "f"));
+        }
     }
     catch (error) {
         __classPrivateFieldSet(this, _TestOpsPlugin_skippedUploadCycle, true, "f");
@@ -500,17 +528,60 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
     if (trsToUpload.length === 0) {
         return;
     }
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadQualityGateResults).call(this, store);
-    const environments = await store.allEnvironmentIdentities();
-    const contextCategories = context?.categories ?? [];
-    const trsEnrichedWithCategories = await enrichWithCategories(store, trsToUpload, contextCategories);
     const categoriesError = await syncLaunchCategories(__classPrivateFieldGet(this, _TestOpsPlugin_client, "f"), trsEnrichedWithCategories, contextCategories);
     if (categoriesError) {
         __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Uploading test results without launch categories: ${categoriesError.message}`);
     }
-    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, trsEnrichedWithCategories, environments, {
-        silent: !!context?.realTime,
-    });
+    const silent = !!context?.realTime;
+    if (groups.base.length > 0) {
+        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, groups.base, environments, {
+            silent,
+            queueName: "test-results",
+            session: async () => baseSession,
+        });
+    }
+    for (const { environmentId, environmentVariables, trs } of groups.withOwnVariables) {
+        await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadTestResults).call(this, store, trs, environments, {
+            silent,
+            queueName: `test-results:${environmentId}`,
+            session: () => __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_environmentSession).call(this, environmentId, environmentVariables),
+            environmentName: environments.find(({ id }) => id === environmentId)?.name ?? environmentId,
+        });
+    }
+    await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_uploadQualityGateResults).call(this, store);
+}, _TestOpsPlugin_groupByEnvironmentVariables = async function _TestOpsPlugin_groupByEnvironmentVariables(store, trs) {
+    const configReportVariables = await store.allVariables();
+    const reportVariables = toSessionVariables(configReportVariables);
+    const base = [];
+    const withOwnVariables = [];
+    const trsByEnvironment = groupBy(trs, (tr) => tr.environment ?? DEFAULT_ENVIRONMENT);
+    for (const [environmentId, environmentTrs] of Object.entries(trsByEnvironment)) {
+        const environmentVariables = await __classPrivateFieldGet(this, _TestOpsPlugin_instances, "m", _TestOpsPlugin_environmentVariables).call(this, store, environmentId, configReportVariables, reportVariables);
+        if (isEqual(environmentVariables, reportVariables)) {
+            for (const tr of environmentTrs) {
+                base.push(tr);
+            }
+        }
+        else {
+            withOwnVariables.push({ environmentId, environmentVariables, trs: environmentTrs });
+        }
+    }
+    return { reportVariables, base, withOwnVariables };
+}, _TestOpsPlugin_environmentIdOf = function _TestOpsPlugin_environmentIdOf(environment, environments) {
+    if (environment === undefined || environments.some(({ id }) => id === environment)) {
+        return environment;
+    }
+    return environments.find(({ name }) => name === environment)?.id ?? environment;
+}, _TestOpsPlugin_environmentVariables = async function _TestOpsPlugin_environmentVariables(store, environmentId, configReportVariables, reportVariables) {
+    try {
+        const merged = await store.envVariablesByEnvironmentId(environmentId);
+        const own = Object.fromEntries(Object.entries(merged).filter(([key, value]) => !Object.hasOwn(configReportVariables, key) || configReportVariables[key] !== value));
+        return { ...reportVariables, ...toSessionVariables(own) };
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Failed to resolve variables of environment ${environmentId}: ${error}`);
+        return reportVariables;
+    }
 }, _TestOpsPlugin_trsToUpload = async function _TestOpsPlugin_trsToUpload(store) {
     const filter = this.options.filter ?? stubTrue;
     const filteredTrs = await store.allTestResults({

package/dist/uploadQueue.d.ts

@@ -8,6 +8,7 @@ export type UploadRunResult<T> = {
 export declare class UploadQueue {
     #private;
     get pendingNames(): string[];
+    get failedNames(): string[];
     run<T>(name: string, task: () => Promise<T>, options?: RetryOptions & {
         onDeferred?: (error?: unknown) => void;
     }): Promise<UploadRunResult<T>>;

package/dist/uploadQueue.js

@@ -9,34 +9,42 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _UploadQueue_pending, _UploadQueue_suspended;
+var _UploadQueue_pending, _UploadQueue_failed, _UploadQueue_suspended;
 import { ErrorKind, classifyError, shouldRetryUpload, withUploadRetry } from "./errors.js";
 const isSuspendingError = (error) => classifyError(error) === ErrorKind.ResourceRecoverable;
 export class UploadQueue {
     constructor() {
         _UploadQueue_pending.set(this, new Map());
+        _UploadQueue_failed.set(this, new Set());
         _UploadQueue_suspended.set(this, false);
     }
     get pendingNames() {
         return [...__classPrivateFieldGet(this, _UploadQueue_pending, "f").keys()];
     }
+    get failedNames() {
+        return [...__classPrivateFieldGet(this, _UploadQueue_failed, "f")];
+    }
     async run(name, task, options = {}) {
         const { onDeferred, ...retryOptions } = options;
         if (__classPrivateFieldGet(this, _UploadQueue_suspended, "f")) {
             __classPrivateFieldGet(this, _UploadQueue_pending, "f").set(name, task);
+            __classPrivateFieldGet(this, _UploadQueue_failed, "f").delete(name);
             onDeferred?.();
             return { deferred: true };
         }
         try {
             const value = await withUploadRetry(task, retryOptions);
             __classPrivateFieldGet(this, _UploadQueue_pending, "f").delete(name);
+            __classPrivateFieldGet(this, _UploadQueue_failed, "f").delete(name);
             return { deferred: false, value };
         }
         catch (error) {
             if (!shouldRetryUpload(error)) {
+                __classPrivateFieldGet(this, _UploadQueue_failed, "f").add(name);
                 throw error;
             }
             __classPrivateFieldGet(this, _UploadQueue_pending, "f").set(name, task);
+            __classPrivateFieldGet(this, _UploadQueue_failed, "f").delete(name);
             __classPrivateFieldSet(this, _UploadQueue_suspended, isSuspendingError(error), "f");
             onDeferred?.(error);
             return { deferred: true };
@@ -58,4 +66,4 @@ export class UploadQueue {
         return [...remaining.keys()];
     }
 }
-_UploadQueue_pending = new WeakMap(), _UploadQueue_suspended = new WeakMap();
+_UploadQueue_pending = new WeakMap(), _UploadQueue_failed = new WeakMap(), _UploadQueue_suspended = new WeakMap();

package/dist/utils/launchCategories.d.ts

@@ -3,5 +3,5 @@ import type { AllureStore } from "@allurereport/plugin-api";
 import type { TestOpsClient } from "../client.js";
 import type { TestOpsPluginTestResult, UploadCategory } from "../model.js";
 export declare const categoryDisplayName: (cat: UploadCategory) => string;
-export declare const enrichWithCategories: (store: AllureStore, trs: TestOpsPluginTestResult[], contextCategories: CategoryDefinition[]) => Promise<TestOpsPluginTestResult[]>;
+export declare const enrichWithCategories: (store: AllureStore, trs: TestOpsPluginTestResult[], contextCategories: CategoryDefinition[], resolveEnvironmentId?: (environment: string | undefined) => string | undefined) => Promise<TestOpsPluginTestResult[]>;
 export declare const syncLaunchCategories: (client: TestOpsClient, trs: TestOpsPluginTestResult[], contextCategories: CategoryDefinition[]) => Promise<Error | undefined>;

package/dist/utils/launchCategories.js

@@ -1,9 +1,9 @@
 import { toUploadCategory } from "./categories.js";
 import { unwrapStepsAttachments } from "./resolvers.js";
 export const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
-export const enrichWithCategories = async (store, trs, contextCategories) => {
+export const enrichWithCategories = async (store, trs, contextCategories, resolveEnvironmentId = (environment) => environment) => {
     return Promise.all(trs.map(async (tr) => {
-        const environmentId = await store.environmentIdByTrId(tr.id);
+        const environmentId = resolveEnvironmentId((await store.environmentIdByTrId(tr.id)) ?? tr.environment);
         const base = {
             ...tr,
             ...(environmentId ? { environment: environmentId } : {}),

package/dist/utils/sessionEnvironment.d.ts

@@ -0,0 +1 @@
+export declare const toSessionVariables: (variables: Record<string, unknown>) => Record<string, string>;

package/dist/utils/sessionEnvironment.js

@@ -0,0 +1,4 @@
+export const toSessionVariables = (variables) => Object.fromEntries(Object.entries(variables)
+    .filter(([, value]) => ["string", "number", "boolean"].includes(typeof value))
+    .map(([key, value]) => [key, String(value)])
+    .filter(([, value]) => value.trim() !== ""));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-testops",
-  "version": "3.21.0",
+  "version": "3.22.0",
   "description": "Allure TestOps Plugin",
   "keywords": [
     "allure",
@@ -27,19 +27,19 @@
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "test": "rimraf ./out && vitest run",
+    "test": "rimraf out && vp test run",
     "test:unit": "yarn test",
-    "lint": "oxlint --import-plugin src test features stories",
-    "lint:fix": "oxlint --import-plugin --fix src test features stories"
+    "lint": "vp lint --import-plugin src test features stories",
+    "lint:fix": "vp lint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.21.0",
-    "@allurereport/cli-commons": "3.21.0",
-    "@allurereport/core-api": "3.21.0",
-    "@allurereport/git": "3.21.0",
-    "@allurereport/plugin-api": "3.21.0",
-    "@allurereport/reader-api": "3.21.0",
-    "@allurereport/service": "3.21.0",
+    "@allurereport/ci": "3.22.0",
+    "@allurereport/cli-commons": "3.22.0",
+    "@allurereport/core-api": "3.22.0",
+    "@allurereport/git": "3.22.0",
+    "@allurereport/plugin-api": "3.22.0",
+    "@allurereport/reader-api": "3.22.0",
+    "@allurereport/service": "3.22.0",
     "axios": "^1.20.0",
     "form-data": "^4.0.6",
     "lodash-es": "^4.18.1",
@@ -47,17 +47,19 @@
     "yoctocolors": "^2"
   },
   "devDependencies": {
-    "@allurereport/test-config": "3.21.0",
+    "@allurereport/common-config": "3.22.0",
     "@types/d3-shape": "^3.1.8",
     "@types/lodash-es": "^4",
     "@types/node": "^20",
-    "@vitest/coverage-istanbul": "^4.1.0",
+    "@vitest/coverage-istanbul": "5.0.4",
     "@vitest/runner": "^2",
-    "@vitest/snapshot": "^5.0.1",
+    "@vitest/snapshot": "5.0.4",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
     "rimraf": "^6",
     "typescript": "^5",
-    "vitest": "^4.1.0"
+    "vite": "@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0",
+    "vitest": "5.0.4"
   }
 }

package/dist/utils/index.d.ts

@@ -1,7 +0,0 @@
-export { toUploadAttachmentDto, uploadFilenameForLink } from "./attachments.js";
-export { toUploadCategory, buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./categories.js";
-export { toUploadFixtureResultDto, toUploadFixturesResultsDto } from "./fixtures.js";
-export { resolvePluginOptions } from "./options.js";
-export { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./resolvers.js";
-export { normalizeTestStepsResults, toUploadResultsDto, toUploadTestResultDto } from "./testResults.js";
-export { validateExecutableName } from "./validation.js";

package/dist/utils/index.js

@@ -1,7 +0,0 @@
-export { toUploadAttachmentDto, uploadFilenameForLink } from "./attachments.js";
-export { toUploadCategory, buildUploadCategoryGrouping, toUploadCategoryFromContext } from "./categories.js";
-export { toUploadFixtureResultDto, toUploadFixturesResultsDto } from "./fixtures.js";
-export { resolvePluginOptions } from "./options.js";
-export { attachmentsResolverFactory, fixturesResolverFactory, unwrapStepsAttachments } from "./resolvers.js";
-export { normalizeTestStepsResults, toUploadResultsDto, toUploadTestResultDto } from "./testResults.js";
-export { validateExecutableName } from "./validation.js";