@allurereport/plugin-testops 3.12.0 → 3.13.0

package/README.md

@@ -78,6 +78,8 @@ The plugin accepts the following options:
 | `endpoint`         | TestOps API endpoint                                                       | `string`  | `undefined`     |
 | `projectId`        | 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`          |
+| `gitFlow`          | When `true`, collect Git metadata for TestOps Git Flow on CI uploads (opt-in)                                 | `boolean` | `false`         |
+| `ancestorLimit`    | How many ancestor commits to attach to the launch for history linking in TestOps | `number`  | `100`           |
 
 ### Using options from environment variables
 
@@ -90,5 +92,7 @@ The plugin automatically reads the following environment variables and uses them
 | `ALLURE_ENDPOINT` | `endpoint` |
 | `ALLURE_LAUNCH_NAME` | `launchName` |
 | `ALLURE_LAUNCH_TAGS` | `launchTags` |
+| `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).

package/dist/client.d.ts

@@ -2,6 +2,7 @@ import type { ClientRequest } from "http";
 import type { AttachmentLink, CiDescriptor, EnvironmentIdentity, TestError, TestResult, TestStatus } from "@allurereport/core-api";
 import type { QualityGateValidationResult } from "@allurereport/plugin-api";
 import { AxiosError, type AxiosResponse } from "axios";
+import type { LaunchGitContextDto } from "./gitFlow/index.js";
 import type { AttachmentForUpload, AttachmentsResolver, FixtureResolver, LaunchCategoryBulkItem, LaunchCategoryBulkResult, TestOpsClientParams, TestOpsNamedEnv, TestOpsPluginTestResult } from "./model.js";
 declare class TestOpsClientError extends AxiosError<{
     message: string;
@@ -25,7 +26,7 @@ export declare class TestOpsClient {
     createLaunchCategoriesBulk(launchId: number, items: LaunchCategoryBulkItem[]): Promise<LaunchCategoryBulkResult[]>;
     startUpload(ci: CiDescriptor): Promise<void>;
     stopUpload(ci: CiDescriptor, status: TestStatus): Promise<void>;
-    createLaunch(launchName: string, launchTags: string[]): Promise<void>;
+    createLaunch(launchName: string, launchTags: string[], gitContext?: LaunchGitContextDto): Promise<void>;
     createSession(environment?: Record<string, unknown>): Promise<void>;
     get namedEnvs(): MapIterator<TestOpsNamedEnv>;
     getNamedEnvFor(id: string): TestOpsNamedEnv | undefined;

package/dist/client.js

@@ -153,7 +153,7 @@ export class TestOpsClient {
         __classPrivateFieldSet(this, _TestOpsClient_uploadInProgress, false, "f");
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose(`CI upload stopped (status: ${status})`);
     }
-    async createLaunch(launchName, launchTags) {
+    async createLaunch(launchName, launchTags, gitContext) {
         __classPrivateFieldGet(this, _TestOpsClient_logger, "f").verbose("Creating launch…");
         const data = await __classPrivateFieldGet(this, _TestOpsClient_client, "f").post("/api/launch", {
             body: {
@@ -162,6 +162,7 @@ export class TestOpsClient {
                 autoclose: true,
                 external: true,
                 tags: launchTags.map((tag) => ({ name: tag })),
+                ...(gitContext ? { gitContext } : {}),
             },
         });
         __classPrivateFieldSet(this, _TestOpsClient_launch, data, "f");

package/dist/gitFlow/LaunchGitFlow.d.ts

@@ -0,0 +1,14 @@
+import type { CiDescriptor } from "@allurereport/core-api";
+import type { Logger } from "../logger.js";
+import type { LaunchGitContextDto } from "./types.js";
+export type LaunchGitFlowParams = {
+    ci: CiDescriptor;
+    gitFlow: boolean;
+    ancestorLimit: number;
+    logger: Logger;
+};
+export declare class LaunchGitFlow {
+    #private;
+    constructor(params: LaunchGitFlowParams);
+    resolve(): LaunchGitContextDto | undefined;
+}

package/dist/gitFlow/LaunchGitFlow.js

@@ -0,0 +1,84 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _LaunchGitFlow_instances, _LaunchGitFlow_ci, _LaunchGitFlow_gitFlow, _LaunchGitFlow_ancestorLimit, _LaunchGitFlow_logger, _LaunchGitFlow_classify;
+import { collectGitFacts, isGitAvailable } from "@allurereport/git";
+import { buildGitFlowContext, shouldAttachGitFlow } from "./context.js";
+import { projectLaunchGitContext } from "./projection.js";
+export class LaunchGitFlow {
+    constructor(params) {
+        _LaunchGitFlow_instances.add(this);
+        _LaunchGitFlow_ci.set(this, void 0);
+        _LaunchGitFlow_gitFlow.set(this, void 0);
+        _LaunchGitFlow_ancestorLimit.set(this, void 0);
+        _LaunchGitFlow_logger.set(this, void 0);
+        __classPrivateFieldSet(this, _LaunchGitFlow_ci, params.ci, "f");
+        __classPrivateFieldSet(this, _LaunchGitFlow_gitFlow, params.gitFlow, "f");
+        __classPrivateFieldSet(this, _LaunchGitFlow_ancestorLimit, params.ancestorLimit, "f");
+        __classPrivateFieldSet(this, _LaunchGitFlow_logger, params.logger, "f");
+    }
+    resolve() {
+        if (!shouldAttachGitFlow(__classPrivateFieldGet(this, _LaunchGitFlow_gitFlow, "f"))) {
+            return undefined;
+        }
+        if (!isGitAvailable()) {
+            __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("git CLI is not available; continuing upload without git context");
+            return undefined;
+        }
+        const facts = collectGitFacts({ ancestorLimit: __classPrivateFieldGet(this, _LaunchGitFlow_ancestorLimit, "f") });
+        const gitFlowContext = buildGitFlowContext({
+            ci: __classPrivateFieldGet(this, _LaunchGitFlow_ci, "f"),
+            facts,
+            ancestorLimit: __classPrivateFieldGet(this, _LaunchGitFlow_ancestorLimit, "f"),
+        });
+        if (!gitFlowContext) {
+            __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("Git Flow metadata could not be collected; continuing upload without git context");
+            return undefined;
+        }
+        const classified = __classPrivateFieldGet(this, _LaunchGitFlow_instances, "m", _LaunchGitFlow_classify).call(this, gitFlowContext);
+        if (!classified) {
+            __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("Pull request git context is incomplete (missing source or target branch); continuing upload without git context");
+            return undefined;
+        }
+        const launchGitContext = projectLaunchGitContext(classified, __classPrivateFieldGet(this, _LaunchGitFlow_ci, "f"));
+        if (!launchGitContext) {
+            __classPrivateFieldGet(this, _LaunchGitFlow_logger, "f").warn("Git provider is not supported by TestOps; continuing upload without git context");
+            return undefined;
+        }
+        return launchGitContext;
+    }
+}
+_LaunchGitFlow_ci = new WeakMap(), _LaunchGitFlow_gitFlow = new WeakMap(), _LaunchGitFlow_ancestorLimit = new WeakMap(), _LaunchGitFlow_logger = new WeakMap(), _LaunchGitFlow_instances = new WeakSet(), _LaunchGitFlow_classify = function _LaunchGitFlow_classify(context) {
+    if (context.pullRequest) {
+        const sourceBranch = context.branch;
+        const targetBranch = context.targetBranch;
+        if (!sourceBranch || !targetBranch) {
+            return undefined;
+        }
+        return {
+            kind: "pull_request",
+            context,
+            sourceBranch,
+            targetBranch,
+        };
+    }
+    if (context.branch) {
+        return {
+            kind: "branch",
+            context,
+            branch: context.branch,
+        };
+    }
+    return {
+        kind: "standalone",
+        context,
+    };
+};

package/dist/gitFlow/context.d.ts

@@ -0,0 +1,9 @@
+import { type CiDescriptor, type GitFacts } from "@allurereport/core-api";
+import type { GitFlowContext } from "./types.js";
+export type BuildGitFlowContextParams = {
+    ci: CiDescriptor;
+    facts?: GitFacts;
+    ancestorLimit: number;
+};
+export declare const shouldAttachGitFlow: (gitFlow: boolean) => boolean;
+export declare const buildGitFlowContext: (params: BuildGitFlowContextParams) => GitFlowContext | undefined;

package/dist/gitFlow/context.js

@@ -0,0 +1,32 @@
+import { GitProvider } from "@allurereport/core-api";
+export const shouldAttachGitFlow = (gitFlow) => gitFlow;
+const nonBlank = (value) => {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+};
+export const buildGitFlowContext = (params) => {
+    const { ci, facts, ancestorLimit } = params;
+    if (!facts?.commit) {
+        return undefined;
+    }
+    const fallbackRepoName = nonBlank(ci.repoName);
+    const repository = ci.repository?.slug ? ci.repository : fallbackRepoName ? { slug: fallbackRepoName } : undefined;
+    if (!repository?.slug) {
+        return undefined;
+    }
+    const provider = ci.provider ?? GitProvider.Other;
+    const branch = nonBlank(ci.sourceBranch) ?? nonBlank(facts.branch) ?? nonBlank(ci.jobRunBranch);
+    const targetBranch = nonBlank(ci.targetBranch);
+    const pullRequest = ci.pullRequest;
+    return {
+        provider,
+        repository,
+        commit: facts.commit,
+        branch,
+        targetBranch,
+        pullRequest,
+        firstParentAncestors: facts.firstParentAncestors,
+        ancestorLimit,
+        localState: facts.localState,
+    };
+};

package/dist/gitFlow/index.d.ts

@@ -0,0 +1,4 @@
+export type { GitFlowContext, GitProviderType, LaunchGitBranchDto, LaunchGitCommitDto, LaunchGitContextDto, LaunchGitContextType, LaunchGitPullRequestDto, LaunchGitRepositoryDto, LaunchPullRequestGitflowMetadata, ResolvedGitFlowOptions, LaunchStandaloneGitflowMetadata, } from "./types.js";
+export { LaunchGitFlow } from "./LaunchGitFlow.js";
+export type { LaunchGitFlowParams } from "./LaunchGitFlow.js";
+export { resolveGitFlowOptions } from "./options.js";

package/dist/gitFlow/index.js

@@ -0,0 +1,2 @@
+export { LaunchGitFlow } from "./LaunchGitFlow.js";
+export { resolveGitFlowOptions } from "./options.js";

package/dist/gitFlow/options.d.ts

@@ -0,0 +1,3 @@
+import type { TestOpsPluginOptions } from "../model.js";
+import type { ResolvedGitFlowOptions } from "./types.js";
+export declare const resolveGitFlowOptions: (options: TestOpsPluginOptions) => ResolvedGitFlowOptions;

package/dist/gitFlow/options.js

@@ -0,0 +1,42 @@
+import { env } from "node:process";
+import { DEFAULT_ANCESTOR_LIMIT } from "@allurereport/git";
+const parseEnvBool = (value) => {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes") {
+        return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no") {
+        return false;
+    }
+    return undefined;
+};
+const resolveGitFlow = (options) => {
+    if (options.gitFlow === true) {
+        return true;
+    }
+    if (options.gitFlow === false) {
+        return false;
+    }
+    return parseEnvBool(env.ALLURE_GIT_FLOW) ?? false;
+};
+const parseAncestorLimit = (value) => {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    if (typeof value === "string" && value !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return DEFAULT_ANCESTOR_LIMIT;
+};
+export const resolveGitFlowOptions = (options) => {
+    return {
+        gitFlow: resolveGitFlow(options),
+        ancestorLimit: parseAncestorLimit(options.ancestorLimit ?? env.ALLURE_GIT_ANCESTOR_LIMIT),
+    };
+};

package/dist/gitFlow/projection.d.ts

@@ -0,0 +1,19 @@
+import { type CiDescriptor } from "@allurereport/core-api";
+import type { GitFlowContext, LaunchGitContextDto } from "./types.js";
+export type ClassifiedPullRequestGitFlowContext = {
+    kind: "pull_request";
+    context: GitFlowContext;
+    sourceBranch: string;
+    targetBranch: string;
+};
+export type ClassifiedBranchGitFlowContext = {
+    kind: "branch";
+    context: GitFlowContext;
+    branch: string;
+};
+export type ClassifiedStandaloneGitFlowContext = {
+    kind: "standalone";
+    context: GitFlowContext;
+};
+export type ClassifiedGitFlowContext = ClassifiedPullRequestGitFlowContext | ClassifiedBranchGitFlowContext | ClassifiedStandaloneGitFlowContext;
+export declare const projectLaunchGitContext: (classified: ClassifiedGitFlowContext, ci?: CiDescriptor) => LaunchGitContextDto | undefined;

package/dist/gitFlow/projection.js

@@ -0,0 +1,195 @@
+import { GitProvider } from "@allurereport/core-api";
+const mapProvider = (provider) => {
+    switch (provider) {
+        case GitProvider.Github:
+            return "github";
+        case GitProvider.Gitlab:
+            return "gitlab";
+        case GitProvider.Bitbucket:
+            return "bitbucket";
+        default:
+            return undefined;
+    }
+};
+const hostMatchesProvider = (host, providerType) => {
+    switch (providerType) {
+        case "github":
+            return host === "github.com" || host.endsWith(".github.com") || host.startsWith("github.");
+        case "gitlab":
+            return host === "gitlab.com" || host.endsWith(".gitlab.com") || host.startsWith("gitlab.");
+        case "bitbucket":
+            return host === "bitbucket.org" || host.endsWith(".bitbucket.org") || host.startsWith("bitbucket.");
+        default:
+            return false;
+    }
+};
+const inferProviderTypeFromUrl = (url) => {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        const host = new URL(url).hostname.toLowerCase();
+        for (const providerType of ["github", "gitlab", "bitbucket"]) {
+            if (hostMatchesProvider(host, providerType)) {
+                return providerType;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+};
+const resolveProviderType = (context) => mapProvider(context.provider) ?? inferProviderTypeFromUrl(context.repository.url);
+const stripGitSuffix = (url) => url.replace(/\.git\/?$/i, "");
+const buildRepositoryUrl = (providerType, slug, repositoryUrl) => {
+    if (repositoryUrl) {
+        return repositoryUrl;
+    }
+    if (providerType === "github") {
+        return `https://github.com/${slug}.git`;
+    }
+    if (providerType === "gitlab") {
+        return `https://gitlab.com/${slug}`;
+    }
+    if (providerType === "bitbucket") {
+        return `https://bitbucket.org/${slug}.git`;
+    }
+    return undefined;
+};
+const buildRepositoryWebUrl = (providerType, slug, repositoryUrl) => {
+    if (repositoryUrl) {
+        return stripGitSuffix(repositoryUrl);
+    }
+    if (providerType === "github") {
+        return `https://github.com/${slug}`;
+    }
+    if (providerType === "gitlab") {
+        return `https://gitlab.com/${slug}`;
+    }
+    if (providerType === "bitbucket") {
+        return `https://bitbucket.org/${slug}`;
+    }
+    return repositoryUrl;
+};
+const buildCommitUrl = (repoWebUrl, hash, providerType) => {
+    if (!repoWebUrl) {
+        return undefined;
+    }
+    if (providerType === "github") {
+        return `${repoWebUrl}/commit/${hash}`;
+    }
+    if (providerType === "gitlab") {
+        return `${repoWebUrl}/-/commit/${hash}`;
+    }
+    return `${repoWebUrl}/commits/${hash}`;
+};
+const buildBranchUrl = (repoWebUrl, branchName, providerType) => {
+    if (!repoWebUrl) {
+        return undefined;
+    }
+    if (providerType === "github") {
+        return `${repoWebUrl}/tree/${branchName}`;
+    }
+    if (providerType === "gitlab") {
+        return `${repoWebUrl}/-/tree/${branchName}`;
+    }
+    return `${repoWebUrl}/branch/${branchName}`;
+};
+const buildPullRequestUrl = (repoWebUrl, externalId, providerType, pullRequestUrl) => {
+    if (pullRequestUrl) {
+        return pullRequestUrl;
+    }
+    if (!repoWebUrl) {
+        return undefined;
+    }
+    if (providerType === "github") {
+        return `${repoWebUrl}/pull/${externalId}`;
+    }
+    if (providerType === "gitlab") {
+        return `${repoWebUrl}/-/merge_requests/${externalId}`;
+    }
+    return `${repoWebUrl}/pull-requests/${externalId}`;
+};
+const toStandaloneMetadata = (localState) => {
+    if (!localState) {
+        return undefined;
+    }
+    return {
+        hasUncommittedChanges: localState.uncommittedChanges,
+        isUnpublishedCommit: localState.unpublishedCommit,
+        isUnpublishedBranch: localState.unpublishedBranch,
+    };
+};
+const toPullRequestMetadata = (ci) => {
+    if (!ci?.jobRunUid && !ci?.jobRunName) {
+        return undefined;
+    }
+    return {
+        workflowRunId: ci.jobRunUid || undefined,
+        workflowRunName: ci.jobRunName || undefined,
+    };
+};
+const toBranchDto = (name, providerType, repoWebUrl) => ({
+    name,
+    url: buildBranchUrl(repoWebUrl, name, providerType),
+});
+const buildRepositoryAndCommit = (context, providerType) => {
+    const repositoryUrl = buildRepositoryUrl(providerType, context.repository.slug, context.repository.url);
+    const repoWebUrl = buildRepositoryWebUrl(providerType, context.repository.slug, repositoryUrl);
+    const lineage = context.firstParentAncestors.length > 0 ? context.firstParentAncestors : undefined;
+    return {
+        repository: {
+            providerType,
+            name: context.repository.slug,
+            url: repositoryUrl,
+        },
+        commit: {
+            hash: context.commit,
+            url: buildCommitUrl(repoWebUrl, context.commit, providerType),
+            lineage,
+        },
+        repoWebUrl,
+    };
+};
+export const projectLaunchGitContext = (classified, ci) => {
+    const context = classified.context;
+    const providerType = resolveProviderType(context);
+    if (!providerType) {
+        return undefined;
+    }
+    const { repository, commit, repoWebUrl } = buildRepositoryAndCommit(context, providerType);
+    if (classified.kind === "pull_request") {
+        const { pullRequest } = context;
+        if (!pullRequest) {
+            return undefined;
+        }
+        return {
+            contextType: "pull_request",
+            repository,
+            commit,
+            pullRequest: {
+                externalId: pullRequest.id,
+                title: pullRequest.title,
+                url: buildPullRequestUrl(repoWebUrl, pullRequest.id, providerType, pullRequest.url),
+                sourceBranch: toBranchDto(classified.sourceBranch, providerType, repoWebUrl),
+                targetBranch: toBranchDto(classified.targetBranch, providerType, repoWebUrl),
+            },
+            metadata: toPullRequestMetadata(ci),
+        };
+    }
+    if (classified.kind === "branch") {
+        return {
+            contextType: "branch",
+            repository,
+            commit,
+            branch: toBranchDto(classified.branch, providerType, repoWebUrl),
+        };
+    }
+    return {
+        contextType: "standalone",
+        repository,
+        commit,
+        metadata: toStandaloneMetadata(context.localState),
+    };
+};

package/dist/gitFlow/types.d.ts

@@ -0,0 +1,56 @@
+import type { GitLocalState, GitProvider, GitPullRequestRef, GitRepositoryRef } from "@allurereport/core-api";
+export type LaunchGitContextType = "branch" | "standalone" | "pull_request";
+export type GitProviderType = "github" | "gitlab" | "bitbucket";
+export type ResolvedGitFlowOptions = {
+    gitFlow: boolean;
+    ancestorLimit: number;
+};
+export interface LaunchGitRepositoryDto {
+    providerType: GitProviderType;
+    name: string;
+    url?: string;
+}
+export interface LaunchGitCommitDto {
+    hash: string;
+    url?: string;
+    lineage?: string[];
+}
+export interface LaunchGitBranchDto {
+    name: string;
+    url?: string;
+}
+export interface LaunchGitPullRequestDto {
+    externalId: string;
+    title?: string;
+    url?: string;
+    sourceBranch: LaunchGitBranchDto;
+    targetBranch: LaunchGitBranchDto;
+}
+export interface LaunchStandaloneGitflowMetadata {
+    hasUncommittedChanges?: boolean;
+    isUnpublishedCommit?: boolean;
+    isUnpublishedBranch?: boolean;
+}
+export interface LaunchPullRequestGitflowMetadata {
+    workflowRunId?: string;
+    workflowRunName?: string;
+}
+export interface LaunchGitContextDto {
+    contextType: LaunchGitContextType;
+    repository: LaunchGitRepositoryDto;
+    commit: LaunchGitCommitDto;
+    branch?: LaunchGitBranchDto;
+    pullRequest?: LaunchGitPullRequestDto;
+    metadata?: LaunchStandaloneGitflowMetadata | LaunchPullRequestGitflowMetadata;
+}
+export interface GitFlowContext {
+    provider: GitProvider;
+    repository: GitRepositoryRef;
+    commit: string;
+    branch?: string;
+    targetBranch?: string;
+    pullRequest?: GitPullRequestRef;
+    firstParentAncestors: string[];
+    ancestorLimit: number;
+    localState?: GitLocalState;
+}

package/dist/gitFlow/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model.d.ts

@@ -193,6 +193,8 @@ export type TestOpsUploaderOptions = {
     launchName: string;
     launchTags: string[];
     autocloseLaunch?: boolean;
+    gitFlow?: boolean;
+    ancestorLimit?: number;
     filter?: (testResult: TestResult) => boolean;
     limit?: number;
 };

package/dist/plugin.d.ts

@@ -1,10 +1,11 @@
-import { type AllureStore, type Plugin, type PluginContext } from "@allurereport/plugin-api";
+import { type AllureStore, type Plugin, type PluginConstructorContext, type PluginContext } from "@allurereport/plugin-api";
 import type { TestOpsPluginOptions } from "./model.js";
 export declare class TestOpsPlugin implements Plugin {
     #private;
     readonly options: TestOpsPluginOptions;
-    constructor(options: TestOpsPluginOptions);
+    constructor(options: TestOpsPluginOptions, context?: PluginConstructorContext);
     get isOverridenByEnv(): boolean;
+    get isManuallyEnabled(): boolean;
     get enabled(): boolean;
     start(context: PluginContext, store: AllureStore): Promise<void>;
     update(context: PluginContext, store: AllureStore): Promise<void>;

package/dist/plugin.js

@@ -1,29 +1,30 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     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 _TestOpsPlugin_instances, _TestOpsPlugin_logger, _TestOpsPlugin_ci, _TestOpsPlugin_client, _TestOpsPlugin_launchName, _TestOpsPlugin_launchTags, _TestOpsPlugin_uploadedTestResultsIds, _TestOpsPlugin_autocloseLaunch, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_enrichWithCategories, _TestOpsPlugin_syncLaunchCategories, _TestOpsPlugin_collectCategoryNamesByExternalId, _TestOpsPlugin_assignCreatedCategoryIds, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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_autocloseLaunch, _TestOpsPlugin_gitFlow, _TestOpsPlugin_enabledByConfig, _TestOpsPlugin_uploadQualityGateResults, _TestOpsPlugin_uploadGlobalErrors, _TestOpsPlugin_uploadGlobalAttachments, _TestOpsPlugin_uploadTestResults, _TestOpsPlugin_upload, _TestOpsPlugin_trsToUpload, _TestOpsPlugin_enrichWithCategories, _TestOpsPlugin_syncLaunchCategories, _TestOpsPlugin_collectCategoryNamesByExternalId, _TestOpsPlugin_assignCreatedCategoryIds, _TestOpsPlugin_startUpload, _TestOpsPlugin_stopUpload;
 import { env } from "node:process";
 import { detect, isLocalCiDescriptor } from "@allurereport/ci";
 import { getWorstStatus } from "@allurereport/core-api";
-import { createPluginSummary } from "@allurereport/plugin-api";
+import { createPluginSummary, } from "@allurereport/plugin-api";
 import { uniqBy, stubTrue } from "lodash-es";
 import { bold } from "yoctocolors";
 import { TestOpsClient } from "./client.js";
+import { LaunchGitFlow, resolveGitFlowOptions } from "./gitFlow/index.js";
 import { Logger } from "./logger.js";
 import { attachmentsResolverFactory, fixturesResolverFactory, resolvePluginOptions, unwrapStepsAttachments, } from "./utils/index.js";
 import { toUploadCategory } from "./utils/uploadCategory.js";
 import { uploadFilenameForLink } from "./utils/uploaderDto.js";
 const categoryDisplayName = (cat) => cat.name ?? cat.grouping?.[0]?.name ?? cat.grouping?.[0]?.value ?? cat.grouping?.[0]?.key ?? cat.externalId;
 export class TestOpsPlugin {
-    constructor(options) {
+    constructor(options, context = {}) {
         _TestOpsPlugin_instances.add(this);
         this.options = options;
         _TestOpsPlugin_logger.set(this, new Logger("TestOpsPlugin"));
@@ -33,7 +34,13 @@ export class TestOpsPlugin {
         _TestOpsPlugin_launchTags.set(this, []);
         _TestOpsPlugin_uploadedTestResultsIds.set(this, new Set());
         _TestOpsPlugin_autocloseLaunch.set(this, false);
-        if (isLocalCiDescriptor(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f")) && !this.isOverridenByEnv) {
+        _TestOpsPlugin_gitFlow.set(this, void 0);
+        _TestOpsPlugin_enabledByConfig.set(this, false);
+        __classPrivateFieldSet(this, _TestOpsPlugin_enabledByConfig, context.enabled === true, "f");
+        if (context.enabled === false) {
+            return;
+        }
+        if (isLocalCiDescriptor(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f")) && !this.isManuallyEnabled) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").info(`plugin is disabled - no CI environment detected. To enable, set ${bold("ALLURE_TESTOPS_ENABLED")}=true or ${bold("CI")}=true.`);
             return;
         }
@@ -48,6 +55,13 @@ export class TestOpsPlugin {
             __classPrivateFieldSet(this, _TestOpsPlugin_launchTags, launchTags, "f");
         }
         __classPrivateFieldSet(this, _TestOpsPlugin_autocloseLaunch, autocloseLaunch, "f");
+        const gitFlowOptions = resolveGitFlowOptions(options);
+        __classPrivateFieldSet(this, _TestOpsPlugin_gitFlow, new LaunchGitFlow({
+            ci: __classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"),
+            gitFlow: gitFlowOptions.gitFlow,
+            ancestorLimit: gitFlowOptions.ancestorLimit,
+            logger: __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f"),
+        }), "f");
         if (!accessToken) {
             __classPrivateFieldGet(this, _TestOpsPlugin_logger, "f").warn(`Allure TestOps ${bold("access token")} is missing. Please provide a valid access token in the plugin options.`);
         }
@@ -67,11 +81,14 @@ export class TestOpsPlugin {
         };
         return isEnabled(env.ALLURE_TESTOPS_ENABLED) || isEnabled(env.CI);
     }
+    get isManuallyEnabled() {
+        return __classPrivateFieldGet(this, _TestOpsPlugin_enabledByConfig, "f") || this.isOverridenByEnv;
+    }
     get enabled() {
         if (!(__classPrivateFieldGet(this, _TestOpsPlugin_client, "f") instanceof TestOpsClient)) {
             return false;
         }
-        if (this.isOverridenByEnv) {
+        if (this.isManuallyEnabled) {
             return true;
         }
         if (!__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f") || __classPrivateFieldGet(this, _TestOpsPlugin_ci, "f").type === "local") {
@@ -150,7 +167,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_autocloseLaunch = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
+_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_autocloseLaunch = new WeakMap(), _TestOpsPlugin_gitFlow = new WeakMap(), _TestOpsPlugin_enabledByConfig = new WeakMap(), _TestOpsPlugin_instances = new WeakSet(), _TestOpsPlugin_uploadQualityGateResults = async function _TestOpsPlugin_uploadQualityGateResults(store) {
     const results = await store.qualityGateResults();
     const uniqueResults = uniqBy(results.filter(({ success }) => !success), ({ rule, environment }) => `${rule}-${environment}`);
     if (uniqueResults.length === 0) {
@@ -393,7 +410,8 @@ _TestOpsPlugin_logger = new WeakMap(), _TestOpsPlugin_ci = new WeakMap(), _TestO
         }
     }
 }, _TestOpsPlugin_startUpload = async function _TestOpsPlugin_startUpload() {
-    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"));
+    const launchGitContext = __classPrivateFieldGet(this, _TestOpsPlugin_gitFlow, "f").resolve();
+    await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").createLaunch(__classPrivateFieldGet(this, _TestOpsPlugin_launchName, "f"), __classPrivateFieldGet(this, _TestOpsPlugin_launchTags, "f"), launchGitContext);
     await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").startUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"));
 }, _TestOpsPlugin_stopUpload = async function _TestOpsPlugin_stopUpload(status) {
     await __classPrivateFieldGet(this, _TestOpsPlugin_client, "f").stopUpload(__classPrivateFieldGet(this, _TestOpsPlugin_ci, "f"), status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-testops",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "description": "Allure Plugin TestOps",
   "keywords": [
     "allure",
@@ -32,11 +32,12 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.12.0",
-    "@allurereport/core-api": "3.12.0",
-    "@allurereport/plugin-api": "3.12.0",
-    "@allurereport/reader-api": "3.12.0",
-    "@allurereport/service": "3.12.0",
+    "@allurereport/ci": "3.13.0",
+    "@allurereport/core-api": "3.13.0",
+    "@allurereport/git": "3.13.0",
+    "@allurereport/plugin-api": "3.13.0",
+    "@allurereport/reader-api": "3.13.0",
+    "@allurereport/service": "3.13.0",
     "axios": "^1.15.2",
     "form-data": "^4.0.5",
     "lodash-es": "^4.18.1",
@@ -45,7 +46,7 @@
     "yoctocolors": "^2"
   },
   "devDependencies": {
-    "@types/d3-shape": "^3.1.6",
+    "@types/d3-shape": "^3.1.8",
     "@types/lodash-es": "^4",
     "@types/node": "^20",
     "@types/progress": "^2",