@testrigor/testrigor-cli 0.0.42-beta

package/dist/commands/test-suite/run.js

@@ -0,0 +1,728 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const Fs = require("@supercharge/fs");
+const FormData = require("form-data");
+const listr2_1 = require("listr2");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const command_base_1 = require("../../command-base");
+const environments_1 = require("../../config/environments");
+const chrome_extension_1 = require("../../flags/chrome-extension");
+const parser_1 = require("../../util/parser");
+const request_builder_1 = require("../../util/request-builder");
+const tunnel_1 = require("../../util/tunnel");
+const utils_1 = require("../../util/utils");
+const sleep = async (milliseconds) => {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+const TEST_SUITE_STATUS = {
+    FINISHED: "Run finished",
+    FAILED: "Run failed",
+    RUNNING: "Run is still in progress",
+    CANCELED: "Run canceled",
+    UNKNOWN: "Unknown status",
+};
+const JUNIT_REPORT_STATUS = {
+    READY: "JUnit report is ready",
+    FAILED: "JUnit report generation is failed",
+    RUNNING: "JUnit report is still in progress",
+};
+class Run extends command_base_1.CommandBase {
+    initializeUrls(flags) {
+        const baseUrlWeb = flags["base-url-web"];
+        const baseUrlApi = flags["base-url-api"];
+        // Validation: if one is set, both must be set
+        if ((baseUrlWeb && !baseUrlApi) || (!baseUrlWeb && baseUrlApi)) {
+            core_1.ux.error("Both --base-url-web and --base-url-api must be set if one is provided");
+        }
+        // If both flags are set, validate and use them
+        if (baseUrlWeb && baseUrlApi) {
+            if (!(0, utils_1.isValidUrl)(baseUrlWeb)) {
+                core_1.ux.error(`Invalid URL for --base-url-web: ${baseUrlWeb}`);
+            }
+            if (!(0, utils_1.isValidUrl)(baseUrlApi)) {
+                core_1.ux.error(`Invalid URL for --base-url-api: ${baseUrlApi}`);
+            }
+            // Remove trailing slashes
+            const cleanBaseUrlWeb = baseUrlWeb.replace(/\/$/, "");
+            const cleanBaseUrlApi = baseUrlApi.replace(/\/$/, "");
+            this.TESTRIGOR_URL = cleanBaseUrlWeb;
+            this.TESTRIGOR_API_URL = `${cleanBaseUrlWeb}/api/v1`;
+            this.TESTRIGOR_API2_URL = `${cleanBaseUrlApi}/api/v1`;
+        }
+        else {
+            // If neither flag is set, use defaults from config
+            const prodConfig = environments_1.environments.prod;
+            const baseWebUrl = prodConfig.TESTRIGOR_WEB_URL;
+            const baseApiUrl = prodConfig.TESTRIGOR_API_URL;
+            this.TESTRIGOR_URL = baseWebUrl;
+            this.TESTRIGOR_API_URL = `${baseWebUrl}/api/v1`;
+            this.TESTRIGOR_API2_URL = `${baseApiUrl}/api/v1`;
+        }
+    }
+    async run() {
+        const flags = this.flags;
+        const args = this.args;
+        this.initializeUrls(flags);
+        const token = await this.resolveToken();
+        const testSuiteId = await this.resolveTestSuiteId(args.testSuiteId);
+        const minPort = flags["min-port"];
+        const maxPort = flags["max-port"];
+        const url = flags["url"];
+        const filePath = flags["file-path"];
+        const variablesPath = flags["variables-path"];
+        const testCasesPath = flags["test-cases-path"];
+        const rulesPath = flags["rules-path"];
+        const settingsPath = flags["settings-path"];
+        const testCaseUuid = flags["test-case-uuid"];
+        const isAutoCreateAIBasedRulesEnabled = flags["auto-create-ai-rules"];
+        const explicitMutations = flags["explicit-mutations"];
+        const labels = flags["labels"];
+        const excludedLabels = flags["excluded-labels"];
+        const chromeExtensions = flags["chrome-extension"];
+        const context = {
+            configuration: {
+                forceCancelPreviousTesting: true,
+                baselineMutations: [],
+                settings: {},
+            },
+            tunnel: new tunnel_1.default(),
+        };
+        if (labels) {
+            context.configuration.labels = labels;
+        }
+        if (excludedLabels) {
+            context.configuration.excludedLabels = excludedLabels;
+        }
+        if (minPort > maxPort) {
+            core_1.ux.error("--minPort cannot be greater than --maxPort");
+        }
+        if (testCaseUuid) {
+            context.configuration.testCaseUuids = [testCaseUuid];
+        }
+        if (isAutoCreateAIBasedRulesEnabled) {
+            context.configuration.isAutoCreateAIBasedRulesEnabled =
+                isAutoCreateAIBasedRulesEnabled;
+        }
+        if (explicitMutations) {
+            context.configuration.explicitMutations = explicitMutations;
+        }
+        if (variablesPath) {
+            try {
+                const file = await Fs.content(variablesPath);
+                context.configuration.storedValues = JSON.parse(file.toString());
+            }
+            catch (e) {
+                core_1.ux.error("--variables-path must be a valid JSON path");
+            }
+        }
+        if (testCasesPath) {
+            try {
+                const testCases = await (0, parser_1.parseTestCases)(testCasesPath);
+                if (testCases.length) {
+                    context.configuration.baselineMutations = testCases;
+                }
+            }
+            catch (e) {
+                core_1.ux.error("--test-cases-path must be a valid JSON path");
+            }
+        }
+        if (rulesPath) {
+            try {
+                const rules = await (0, parser_1.parseRules)(rulesPath);
+                if (rules.length) {
+                    context.configuration.ruleMutations = rules;
+                }
+            }
+            catch (e) {
+                core_1.ux.error("--rules-path must be a valid JSON path");
+            }
+        }
+        if (settingsPath) {
+            try {
+                const settings = await (0, parser_1.parseSettings)(settingsPath);
+                if (settings) {
+                    context.configuration.settings = settings;
+                }
+            }
+            catch (e) {
+                core_1.ux.error("--settings-path must be a valid JSON/YAML path");
+            }
+        }
+        if (filePath) {
+            if (url) {
+                core_1.ux.info("WARNING: File path will be ignored because --url is used");
+                delete flags["file-path"];
+            }
+            else {
+                const fileExists = await Fs.isFile(filePath);
+                if (!fileExists || !(0, utils_1.isValidFileExtensionToUpload)(filePath)) {
+                    core_1.ux.error("--file-path must be one of the valid format types: [zip, exe, msi, apk, aab, ipa, app]");
+                }
+                const fileName = Fs.basename(filePath);
+                const fileSize = Fs.statSync(filePath).size;
+                context.fileProperties = { fileName, fileSize };
+            }
+        }
+        if (chromeExtensions?.length) {
+            context.chromeExtensions = chromeExtensions;
+        }
+        super.setTunnel(context.tunnel);
+        const tasks = [
+            {
+                enabled: () => flags.localhost,
+                task: (ctx, task) => {
+                    if (flags.verbose) {
+                        task.title = "Initializing tunnel";
+                    }
+                    else {
+                        task.title = "Initializing";
+                    }
+                    return task.newListr([
+                        {
+                            task: async (ctx, task) => {
+                                if (flags.verbose) {
+                                    task.title = "Downloading binary";
+                                }
+                                await ctx.tunnel.initialize();
+                            },
+                            rendererOptions: {
+                                timer: listr2_1.PRESET_TIMER,
+                            },
+                        },
+                        {
+                            task: async (ctx, task) => {
+                                if (flags.verbose) {
+                                    task.title = "Starting tunnel";
+                                }
+                                await ctx.tunnel.start(minPort, maxPort);
+                            },
+                            exitOnError: true,
+                            rendererOptions: {
+                                timer: listr2_1.PRESET_TIMER,
+                            },
+                        },
+                        {
+                            enabled: (ctx) => ctx.tunnel.isRunning(),
+                            task: (ctx, task) => {
+                                if (flags.verbose) {
+                                    task.title = `Tunnel started at port ${ctx.tunnel.getPort()}`;
+                                }
+                                ctx.configuration.settings = {
+                                    ...ctx.configuration.settings,
+                                    httpProxyString: `tunnel.testrigor.com:${ctx.tunnel.getPort()}`,
+                                };
+                            },
+                        },
+                    ], { concurrent: false, rendererOptions: { collapseSubtasks: false } });
+                },
+            },
+            {
+                title: "Running test suite",
+                task: async (ctx, task) => task.newListr([
+                    {
+                        // Checking last run id
+                        task: async (ctx) => {
+                            const statusResponse = await this.fetchStatus(testSuiteId, token, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                            context.lastRunId = (0, utils_1.extractRunIdFromDetailsUrl)(statusResponse.detailsUrl);
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        enabled: () => !flags["file-path"] && !flags["chrome-extension"],
+                        task: async (ctx) => {
+                            if (flags.url) {
+                                ctx.configuration.url = flags.url;
+                            }
+                            if (flags.branch && flags.commit) {
+                                ctx.configuration.branch = {
+                                    name: flags.branch,
+                                    commit: flags.commit,
+                                };
+                            }
+                            const response = await this.callRetest(testSuiteId, ctx.configuration, token);
+                            ctx.response = (await response.json());
+                            if (!response.ok) {
+                                const errorMessage = JSON.stringify(ctx.response);
+                                throw new Error(`Test suite failed to start: ${ctx.response?.msg ||
+                                    ctx.response?.errName ||
+                                    errorMessage}`);
+                            }
+                            if (ctx.response?.taskId) {
+                                task.title = `Running test suite [ ${this.TESTRIGOR_URL}/test-suites/${testSuiteId}/runs/${ctx.response?.taskId} ]`;
+                            }
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Uploading Chrome extension(s)",
+                        enabled: () => !!context.chromeExtensions?.length,
+                        task: async (ctx) => {
+                            if (flags.url) {
+                                ctx.configuration.url = flags.url;
+                            }
+                            if (flags.branch && flags.commit) {
+                                ctx.configuration.branch = {
+                                    name: flags.branch,
+                                    commit: flags.commit,
+                                };
+                            }
+                            const { form, cleanup } = (0, request_builder_1.buildChromeExtensionFormData)(ctx.chromeExtensions);
+                            form.append("data", JSON.stringify(ctx.configuration));
+                            const controller = new AbortController();
+                            const timeoutId = setTimeout(() => controller.abort(), utils_1.UPLOAD_TIMEOUT_MS);
+                            try {
+                                // Prepare headers
+                                const requestHeaders = {
+                                    ...form.getHeaders(),
+                                    Accept: "application/json",
+                                    "auth-token": token,
+                                };
+                                const response = await (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API2_URL}/apps/${testSuiteId}/retest`, {
+                                    method: "POST",
+                                    body: form,
+                                    headers: requestHeaders,
+                                    signal: controller.signal,
+                                });
+                                const retestApi2Response = (await response.json());
+                                if (!response.ok || retestApi2Response.status >= 300) {
+                                    throw new Error(`Chrome extension upload failed: ${retestApi2Response?.message ||
+                                        retestApi2Response?.errors}`);
+                                }
+                                ctx.response = {
+                                    result: "ok",
+                                    msg: retestApi2Response.message,
+                                    taskId: retestApi2Response.data?.taskId,
+                                    queueId: retestApi2Response.data?.queueId,
+                                };
+                                if (ctx.response?.taskId) {
+                                    task.title = `Running test suite [ ${this.TESTRIGOR_URL}/test-suites/${testSuiteId}/runs/${ctx.response?.taskId} ]`;
+                                }
+                            }
+                            catch (error) {
+                                if (error.name === "AbortError") {
+                                    throw new Error("Chrome extension upload timed out. Please check your network connection.");
+                                }
+                                throw error;
+                            }
+                            finally {
+                                clearTimeout(timeoutId);
+                                cleanup();
+                            }
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Uploading file",
+                        enabled: () => context.fileProperties &&
+                            context.fileProperties.fileSize < utils_1.MAX_FILE_SIZE_100_MB,
+                        task: async (ctx) => {
+                            if (flags.branch && flags.commit) {
+                                ctx.configuration.branch = {
+                                    name: flags.branch,
+                                    commit: flags.commit,
+                                };
+                            }
+                            if (!flags["file-path"]) {
+                                throw new Error("file-path is not provided");
+                            }
+                            const configuration = ctx.configuration;
+                            const filePath = flags["file-path"];
+                            const form = new FormData();
+                            form.append("file", Fs.createReadStream(filePath));
+                            form.append("data", JSON.stringify(configuration));
+                            const response = await (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API2_URL}/apps/${testSuiteId}/retest`, {
+                                method: "POST",
+                                body: form,
+                                headers: {
+                                    ...form.getHeaders(),
+                                    Accept: "application/json",
+                                    "auth-token": token,
+                                },
+                            });
+                            const retestApi2Response = (await response.json());
+                            if (!response.ok || retestApi2Response.status >= 300) {
+                                throw new Error(`Test suite failed to start: ${retestApi2Response?.message ||
+                                    retestApi2Response?.errors}`);
+                            }
+                            ctx.response = {
+                                result: "ok",
+                                msg: retestApi2Response.message,
+                                taskId: retestApi2Response.data?.taskId,
+                                queueId: retestApi2Response.data?.queueId,
+                            };
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Uploading file (> 100 MB)",
+                        enabled: () => context.fileProperties &&
+                            context.fileProperties.fileSize >= utils_1.MAX_FILE_SIZE_100_MB,
+                        task: async (ctx) => {
+                            if (flags.branch && flags.commit) {
+                                ctx.configuration.branch = {
+                                    name: flags.branch,
+                                    commit: flags.commit,
+                                };
+                            }
+                            if (!flags["file-path"]) {
+                                throw new Error("file-path is not provided");
+                            }
+                            if (!ctx.fileProperties) {
+                                throw new Error(`Error getting details of file provided by --file-path ${flags["file-path"]}`);
+                            }
+                            const configuration = ctx.configuration;
+                            const filePath = flags["file-path"];
+                            const response = await this.uploadFile(task, testSuiteId, configuration, filePath, token, ctx.fileProperties);
+                            ctx.response = (await response.json());
+                            if (!response.ok) {
+                                throw new Error(`Test suite failed to start: ${ctx.response?.msg || ctx.response?.errName}`);
+                            }
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Waiting for test suite run creation",
+                        enabled: (ctx) => ctx.response?.queueId,
+                        task: async (ctx, currentTask) => {
+                            const detailsUrl = await this.waitForTestSuiteToBeCreated(testSuiteId, token, ctx.lastRunId, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                            task.title = `Running test suite [ ${detailsUrl} ]`;
+                            currentTask.title = "Test suite run created successfully";
+                        },
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Checking status",
+                        enabled: (ctx) => ctx.response?.result === "ok" && !flags.async,
+                        task: async (ctx, task) => task.newListr([
+                            {
+                                task: async (ctx, statusTask) => {
+                                    await this.waitForTestSuiteToFinish(testSuiteId, token, statusTask, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                                },
+                            },
+                        ]),
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Generating JUnit report",
+                        enabled: (ctx) => ctx.response?.result === "ok" &&
+                            !flags.async &&
+                            flags["junit-report-save-path"] &&
+                            ctx.response?.taskId,
+                        task: async (ctx, task) => task.newListr([
+                            {
+                                task: async (ctx, statusTask) => {
+                                    await this.startAndWaitForJunitReportToFinish(testSuiteId, String(ctx.response?.taskId), String(flags["junit-report-save-path"]), token, statusTask);
+                                },
+                            },
+                        ]),
+                        exitOnError: false,
+                    },
+                ], {
+                    concurrent: false,
+                    rendererOptions: { collapseSubtasks: false, timer: listr2_1.PRESET_TIMER },
+                    fallbackRendererCondition: true,
+                    fallbackRendererOptions: { timer: listr2_1.PRESET_TIMER },
+                }),
+                exitOnError: false,
+                rendererOptions: {
+                    timer: listr2_1.PRESET_TIMER,
+                },
+            },
+            {
+                enabled: (ctx) => ctx.tunnel.isRunning(),
+                task: async (ctx, task) => {
+                    if (flags.verbose) {
+                        task.title = "Stopping tunnel";
+                    }
+                    await ctx.tunnel.stop();
+                },
+            },
+        ];
+        const runner = new listr2_1.Listr(tasks, {
+            ctx: context,
+            concurrent: false,
+            collectErrors: "minimal",
+            renderer: (0, utils_1.rendererToUse)(),
+        });
+        await runner.run().catch(() => this.exit(1));
+        if (runner.errors?.length > 0) {
+            core_1.ux.error(runner.errors[0].message, { exit: 1 });
+        }
+        this.exit(0);
+    }
+    async fetchStatus(testSuiteId, token, branch, labels, excludedLabels) {
+        const statusApiEndpoint = this.getStatusApiEndpoint(testSuiteId, branch, labels, excludedLabels);
+        const response = await (0, node_fetch_commonjs_1.default)(statusApiEndpoint, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                "auth-token": token,
+            },
+        });
+        if (!response.ok) {
+            return {};
+        }
+        return response.json();
+    }
+    getStatusApiEndpoint(testSuiteId, branch, labels, excludedLabels) {
+        const apiEndpoint = `${this.TESTRIGOR_API_URL}/apps/${testSuiteId}/status`;
+        const queryParams = new URLSearchParams();
+        if (branch) {
+            queryParams.append("branchName", branch);
+        }
+        if (labels && labels.length > 0) {
+            queryParams.append("labels", labels.join(","));
+        }
+        if (excludedLabels && excludedLabels.length > 0) {
+            queryParams.append("excludedLabels", excludedLabels.join(","));
+        }
+        const queryString = queryParams.toString();
+        return queryString ? `${apiEndpoint}?${queryString}` : apiEndpoint;
+    }
+    async callRetest(testSuiteId, configuration, token) {
+        return (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API_URL}/apps/${testSuiteId}/retest`, {
+            method: "POST",
+            body: JSON.stringify(configuration),
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                "auth-token": token,
+            },
+        });
+    }
+    async uploadFile(task, testSuiteId, configuration, filePath, token, fileProperties) {
+        const body = {
+            fileName: fileProperties.fileName,
+        };
+        const preSignedUrl = await (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API2_URL}/apps/${testSuiteId}/retest/pre-signed-url`, {
+            method: "POST",
+            body: JSON.stringify(body),
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                "auth-token": token,
+            },
+        });
+        const preSignedUrlResponse = (await preSignedUrl.json());
+        if (!preSignedUrl.ok ||
+            preSignedUrlResponse.status !== 200 ||
+            !preSignedUrlResponse.data) {
+            throw new Error(`Failed to prepare upload: ${preSignedUrlResponse.message}`);
+        }
+        const preSignedUrlData = preSignedUrlResponse.data;
+        const fileToBeUploaded = Fs.createReadStream(filePath);
+        const uploadFileResponse = await (0, node_fetch_commonjs_1.default)(preSignedUrlData.url, {
+            method: "PUT",
+            body: fileToBeUploaded,
+            headers: {
+                "Content-length": `${fileProperties.fileSize}`,
+            },
+        });
+        if (!uploadFileResponse.ok) {
+            throw new Error(`Failed to upload file: ${uploadFileResponse.statusText}`);
+        }
+        configuration.fileUrl = (0, utils_1.extractUrlWithoutQueryParams)(preSignedUrlData.url);
+        return this.callRetest(testSuiteId, configuration, token);
+    }
+    async waitForTestSuiteToBeCreated(testSuiteId, token, lastRunId, branch, labels, excludedLabels) {
+        for (;;) {
+            const statusResponse = await this.fetchStatus(testSuiteId, token, branch, labels, excludedLabels);
+            const currentRunId = (0, utils_1.extractRunIdFromDetailsUrl)(statusResponse.detailsUrl);
+            if (currentRunId !== lastRunId) {
+                return `${this.TESTRIGOR_URL}/suites/${testSuiteId}/runs/${currentRunId}`;
+            }
+            await sleep(10000);
+        }
+    }
+    async waitForTestSuiteToFinish(testSuiteId, token, task, branch, labels, excludedLabels) {
+        const statusApiEndpoint = this.getStatusApiEndpoint(testSuiteId, branch, labels, excludedLabels);
+        let hasReceivedValidStatus = false;
+        for (;;) {
+            // eslint-disable-next-line no-await-in-loop
+            let response = await this.fetchTestSuiteStatus(statusApiEndpoint, token);
+            if (response.status === 200) {
+                hasReceivedValidStatus = true;
+                task.title = TEST_SUITE_STATUS.FINISHED;
+                break;
+            }
+            if (response.status === 230) {
+                hasReceivedValidStatus = true;
+                throw new Error(TEST_SUITE_STATUS.FAILED);
+            }
+            if (response.status === 229) {
+                hasReceivedValidStatus = true;
+                throw new Error(TEST_SUITE_STATUS.CANCELED);
+            }
+            //RUNNING OR NEW
+            if (response.status === 228 || response.status === 227) {
+                hasReceivedValidStatus = true;
+                task.title = TEST_SUITE_STATUS.RUNNING;
+                if ((0, utils_1.isRunningOnCi)()) {
+                    task.output = TEST_SUITE_STATUS.RUNNING;
+                }
+                await sleep(10000);
+                continue;
+            }
+            // Unknown status handling
+            if (hasReceivedValidStatus) {
+                // Retry with exponential backoff after valid status was seen
+                response = await this.retryForValidStatus(statusApiEndpoint, token, response.status, task);
+                // Continue the loop to process the (hopefully valid) response
+                continue;
+            }
+            else {
+                // First occurrence of unknown status - fail immediately
+                throw new Error(`Unknown status: ${response.status}`);
+            }
+        }
+    }
+    async fetchTestSuiteStatus(statusApiEndpoint, token) {
+        return await (0, node_fetch_commonjs_1.default)(statusApiEndpoint, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                "auth-token": token,
+            },
+        });
+    }
+    async retryForValidStatus(statusApiEndpoint, token, initialStatus, task) {
+        // Retry delays: 1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120 seconds
+        const retryDelays = [1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120];
+        for (const delaySeconds of retryDelays) {
+            if ((0, utils_1.isRunningOnCi)()) {
+                task.output = `Unknown status ${initialStatus}, retrying in ${delaySeconds}s...`;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(delaySeconds * 1000);
+            // eslint-disable-next-line no-await-in-loop
+            const retryResponse = await this.fetchTestSuiteStatus(statusApiEndpoint, token);
+            // Check if we got a valid status back
+            if ([200, 227, 228, 229, 230].includes(retryResponse.status)) {
+                if ((0, utils_1.isRunningOnCi)()) {
+                    task.output = `Recovered with status ${retryResponse.status}`;
+                }
+                return retryResponse;
+            }
+            // Update status for next retry
+            initialStatus = retryResponse.status;
+        }
+        // If we exhausted all retries, throw error
+        throw new Error(`Unknown status: ${initialStatus} (failed after ${retryDelays.length} retries)`);
+    }
+    async startAndWaitForJunitReportToFinish(testSuiteId, runId, savePath, token, task) {
+        const url = `${this.TESTRIGOR_API2_URL}/apps/${testSuiteId}/runs/${runId}/junit_report`;
+        for (;;) {
+            // eslint-disable-next-line no-await-in-loop
+            const response = await (0, node_fetch_commonjs_1.default)(url, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                    "auth-token": token,
+                },
+            });
+            if (response.status === 200) {
+                const contentType = response.headers.get("content-type");
+                if (contentType !== "application/xml") {
+                    throw new Error(`Unexpected contentType of junit report: ${contentType}`);
+                }
+                const xmlData = await response.text();
+                await Fs.writeFile(savePath, xmlData);
+                task.title = JUNIT_REPORT_STATUS.READY;
+                return;
+            }
+            else if (response.status !== 228) {
+                throw new Error(`JUnit report generation failed with status: ${response.status}`);
+            }
+            task.title = JUNIT_REPORT_STATUS.RUNNING;
+            if ((0, utils_1.isRunningOnCi)()) {
+                task.output = JUNIT_REPORT_STATUS.RUNNING;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(10000);
+        }
+    }
+}
+exports.default = Run;
+Run.description = "Run all tests of a Test Suite";
+Run.examples = [];
+Run.flags = {
+    async: core_1.Flags.boolean({
+        char: "w",
+        description: "Don't wait for the test suite to finish",
+        aliases: ["nowait"],
+        default: false,
+    }),
+    branch: core_1.Flags.string({
+        description: "The branch name",
+        env: "TR_BRANCH",
+        dependsOn: ["commit"],
+    }),
+    commit: core_1.Flags.string({
+        description: "The commit",
+        env: "TR_COMMIT",
+        dependsOn: ["branch"],
+    }),
+    localhost: core_1.Flags.boolean({
+        description: "Localhost run",
+        aliases: ["tunnel"],
+        dependsOn: ["url"],
+    }),
+    url: core_1.Flags.string({
+        description: "The url",
+    }),
+    "file-path": core_1.Flags.string({
+        description: "Path to the file stored locally. It will upload the new file to be used. File type should be according to the file type accepted for the Test Suite type of testing. If the parameter --url is used, this parameter will be ignored.",
+    }),
+    "junit-report-save-path": core_1.Flags.string({
+        description: "JUnit report save path",
+    }),
+    "variables-path": core_1.Flags.string({
+        description: "Variables path",
+    }),
+    "test-cases-path": core_1.Flags.string({
+        description: "Test cases files",
+    }),
+    "rules-path": core_1.Flags.string({
+        description: "Rules path",
+    }),
+    "settings-path": core_1.Flags.string({
+        description: "Settings path",
+    }),
+    "test-case-uuid": core_1.Flags.string({
+        description: "Test case uuid",
+        dependsOn: ["url"],
+    }),
+    "auto-create-ai-rules": core_1.Flags.boolean({
+        description: "Enable auto create AI based rules",
+        default: false,
+    }),
+    "explicit-mutations": core_1.Flags.boolean({
+        description: 'In cases where you are always using mutations, such as storing test cases in your own repository, and you always send us the set of test cases you have through our API you should send "--explicit-mutations"',
+        default: false,
+    }),
+    labels: core_1.Flags.string({
+        description: "Run tests of specific labels",
+        multiple: true,
+    }),
+    "excluded-labels": core_1.Flags.string({
+        description: "Not run tests of specific labels",
+        multiple: true,
+    }),
+    "base-url-web": core_1.Flags.string({
+        description: "Base URL for web interface (e.g., https://app.testrigor.com)",
+    }),
+    "base-url-api": core_1.Flags.string({
+        description: "Base URL for API2 (e.g., https://api2.testrigor.com)",
+    }),
+    "chrome-extension": (0, chrome_extension_1.ChromeExtensionFlag)({
+        exclusive: ["file-path"],
+    }),
+};
+Run.args = {
+    testSuiteId: core_1.Args.string({
+        name: "testSuiteId",
+        description: "The test suite id (optional if set in config)",
+        required: false,
+    }),
+};