@smartbear/mcp 0.11.0 → 0.12.1

package/dist/bugsnag/input-schemas.js

@@ -3,25 +3,32 @@ const filterValueSchema = z.object({
     type: z.enum(["eq", "ne", "empty"]),
     value: z.union([z.string(), z.boolean(), z.number()]),
 });
+const filtersSchema = z.record(z.array(filterValueSchema));
 /**
  * A collection of input parameter schemas for reuse between tools.
  * Add new entries when common parameters are identified.
  */
 export const toolInputParameters = {
     empty: z.object({}).describe("No parameters are required for this tool"),
+    buildId: z.string().describe("Unique identifier of the app build"),
+    errorId: z.string().describe("Unique identifier of the error"),
+    eventId: z.string().describe("Unique identifier of the event"),
     projectId: z
         .string()
         .optional()
-        .describe("ID of the project. This is optional if a current project is set and is used to set the current project for BugSnag tools."),
-    errorId: z.string().describe("Unique identifier of the error"),
-    releaseId: z.string().describe("ID of the release"),
-    buildId: z.string().describe("ID of the build"),
+        .describe("Unique identifier of the project. This is optional if a current project is set and is used to set the current project for BugSnag tools."),
+    releaseId: z.string().describe("Unique identifier of the app release"),
     direction: z
         .enum(["asc", "desc"])
         .describe("Sort direction for ordering results")
         .default("desc"),
-    filters: z
-        .record(z.array(filterValueSchema))
+    performanceFilters: filtersSchema
+        .describe("Apply filters to narrow down the span group list. Use the List Trace Fields tool to discover available filter fields. " +
+        "Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h).")
+        .default({
+        "span.since": [{ type: "eq", value: "7d" }],
+    }),
+    filters: filtersSchema
         .describe("Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields. " +
         "Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h).")
         .default({
@@ -48,4 +55,5 @@ export const toolInputParameters = {
         .enum(["first_seen", "last_seen", "events", "users", "unsorted"])
         .describe("Field to sort the errors by")
         .default("last_seen"),
+    spanGroupId: z.string().describe("ID of the span group"),
 };

package/dist/common/transport-stdio.js

@@ -1,5 +1,6 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { clientRegistry } from "./client-registry.js";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.js";
 import { SmartBearMcpServer } from "./server.js";
 /**
  * Generate a dynamic error message listing all available clients and their required env vars
@@ -22,6 +23,10 @@ function getNoConfigErrorMessage() {
  * Run server in STDIO mode (default)
  */
 export async function runStdioMode() {
+    if (process.argv.includes("--version")) {
+        console.log(`${MCP_SERVER_NAME}: v${MCP_SERVER_VERSION}`);
+        process.exit(0);
+    }
     const server = new SmartBearMcpServer();
     // Setup clients from environment variables
     const configuredCount = await clientRegistry.configure(server, (client, key) => {

package/dist/qmetry/client/auto-resolve.js

@@ -25,6 +25,16 @@ export const AUTO_RESOLVE_MODULES = [
         viewIdPath: "latestViews.TS.viewId",
         moduleName: "Test Suites",
     },
+    {
+        handler: QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN,
+        viewIdPath: "latestViews.TE.viewId",
+        moduleName: "Test Case Run By Test Suite Run",
+    },
+    {
+        handler: QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE,
+        viewIdPath: "latestViews.TEL.viewId",
+        moduleName: "Executions By Test Suites",
+    },
     {
         handler: QMetryToolsHandlers.FETCH_TESTSUITES_FOR_TESTCASE,
         viewIdPath: "latestViews.TSFS.viewId",

package/dist/qmetry/client/automation.js

@@ -0,0 +1,171 @@
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../../common/info.js";
+import { QMETRY_DEFAULTS } from "../config/constants.js";
+import { QMETRY_PATHS } from "../config/rest-endpoints.js";
+import { DEFAULT_IMPORT_AUTOMATION_PAYLOAD } from "../types/automation.js";
+import { qmetryRequest } from "./api/client-api.js";
+import { handleQMetryApiError } from "./api/error-handler.js";
+/**
+ * Imports automation test results into QMetry
+ *
+ * This function handles file upload via FormData to import automation test results
+ * from various frameworks (TestNG, JUnit, Cucumber, Robot, etc.)
+ *
+ * CRITICAL NOTES:
+ * - User MUST provide a valid result file (.json, .xml, or .zip up to 30 MB)
+ * - File should be base64 encoded or provided as file path
+ * - EntityType is required and determines the framework format
+ * - Various parameters control test case/suite creation and linking behavior
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key (used in header, can be overridden by projectID in payload)
+ * @param payload - Import configuration including file data, entityType, and optional parameters
+ * @returns Promise resolving to import result with test suite and execution details
+ */
+export async function importAutomationResults(token, baseUrl, project, payload) {
+    // Merge with defaults
+    const finalPayload = {
+        ...DEFAULT_IMPORT_AUTOMATION_PAYLOAD,
+        ...payload,
+    };
+    // Create FormData for multipart/form-data upload
+    const formData = new FormData();
+    // Handle file upload
+    // The file should be provided as base64 string or file content
+    let fileBlob;
+    if (finalPayload.file.startsWith("data:")) {
+        // Base64 data URI format
+        const base64Data = finalPayload.file.split(",")[1];
+        const binaryData = atob(base64Data);
+        const bytes = new Uint8Array(binaryData.length);
+        for (let i = 0; i < binaryData.length; i++) {
+            bytes[i] = binaryData.charCodeAt(i);
+        }
+        fileBlob = new Blob([bytes]);
+    }
+    else if (finalPayload.file.startsWith("/") ||
+        finalPayload.file.includes(":\\")) {
+        // File path - read file from filesystem (Node.js only)
+        try {
+            const fs = await import("node:fs/promises");
+            const fileBuffer = await fs.readFile(finalPayload.file);
+            fileBlob = new Blob([new Uint8Array(fileBuffer)]);
+        }
+        catch (error) {
+            throw new Error(`Failed to read file from path: ${finalPayload.file}. Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    else {
+        // Assume raw base64 string
+        try {
+            const binaryData = atob(finalPayload.file);
+            const bytes = new Uint8Array(binaryData.length);
+            for (let i = 0; i < binaryData.length; i++) {
+                bytes[i] = binaryData.charCodeAt(i);
+            }
+            fileBlob = new Blob([bytes]);
+        }
+        catch (_error) {
+            throw new Error("Invalid file format. Please provide base64 encoded file content or file path.");
+        }
+    }
+    // Add file to FormData
+    formData.append("file", fileBlob, finalPayload.fileName);
+    // Add required entityType
+    formData.append("entityType", finalPayload.entityType);
+    // Add optional parameters
+    if (finalPayload.automationHierarchy) {
+        formData.append("automationHierarchy", finalPayload.automationHierarchy);
+    }
+    if (finalPayload.testsuiteName) {
+        formData.append("testsuiteName", finalPayload.testsuiteName);
+    }
+    if (finalPayload.testsuiteId) {
+        formData.append("testsuiteId", finalPayload.testsuiteId);
+    }
+    if (finalPayload.tsFolderPath) {
+        formData.append("tsFolderPath", finalPayload.tsFolderPath);
+    }
+    if (finalPayload.tcFolderPath) {
+        formData.append("tcFolderPath", finalPayload.tcFolderPath);
+    }
+    if (finalPayload.platformID) {
+        formData.append("platformID", finalPayload.platformID);
+    }
+    if (finalPayload.projectID) {
+        formData.append("projectID", finalPayload.projectID);
+    }
+    if (finalPayload.releaseID) {
+        formData.append("releaseID", finalPayload.releaseID);
+    }
+    if (finalPayload.cycleID) {
+        formData.append("cycleID", finalPayload.cycleID);
+    }
+    if (finalPayload.buildID) {
+        formData.append("buildID", finalPayload.buildID);
+    }
+    if (finalPayload.testcase_fields) {
+        formData.append("testcase_fields", finalPayload.testcase_fields);
+    }
+    if (finalPayload.testsuite_fields) {
+        formData.append("testsuite_fields", finalPayload.testsuite_fields);
+    }
+    if (finalPayload.skipWarning) {
+        formData.append("skipWarning", finalPayload.skipWarning);
+    }
+    if (finalPayload.is_matching_required) {
+        formData.append("is_matching_required", finalPayload.is_matching_required);
+    }
+    // Make API request
+    const url = `${baseUrl || QMETRY_DEFAULTS.BASE_URL}${QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS}`;
+    const headers = {
+        apikey: token,
+        project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
+        "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+        // Note: Content-Type will be set automatically by fetch for FormData
+    };
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to import automation results. Network error: ${error instanceof Error ? error.message : String(error)}\n\nPlease check:\n- QMetry server is accessible\n- File size is under 30 MB\n- File format is .json, .xml, or .zip`);
+    }
+    if (!res.ok) {
+        await handleQMetryApiError(res, baseUrl || QMETRY_DEFAULTS.BASE_URL, project || QMETRY_DEFAULTS.PROJECT_KEY, QMETRY_PATHS.AUTOMATION.IMPORT_RESULTS);
+    }
+    return await res.json();
+}
+/**
+ * Fetches automation status by request ID from QMetry
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param requestID - Numeric request ID from import automation response
+ * @returns Promise resolving to automation status
+ */
+export async function getAutomationStatus(token, baseUrl, project, requestID) {
+    let numericRequestID;
+    if (typeof requestID === "object" &&
+        requestID !== null &&
+        "requestID" in requestID &&
+        typeof requestID.requestID !== "undefined") {
+        numericRequestID = Number(requestID.requestID);
+    }
+    else {
+        numericRequestID = Number(requestID);
+    }
+    if (!numericRequestID || Number.isNaN(numericRequestID)) {
+        throw new Error("requestID must be a valid number");
+    }
+    return qmetryRequest({
+        method: "GET",
+        path: QMETRY_PATHS.AUTOMATION.GET_STATUS.replace(":requestID", String(numericRequestID)),
+        token,
+        baseUrl: baseUrl || QMETRY_DEFAULTS.BASE_URL,
+        project: project || QMETRY_DEFAULTS.PROJECT_KEY,
+    });
+}

package/dist/qmetry/client/handlers.js

@@ -1,9 +1,10 @@
 import { QMetryToolsHandlers } from "../config/constants.js";
+import { getAutomationStatus, importAutomationResults } from "./automation.js";
 import { createIssue, fetchIssues, fetchIssuesLinkedToTestCase, linkIssuesToTestcaseRun, updateIssue, } from "./issues.js";
-import { getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, } from "./project.js";
+import { createCycle, createRelease, getBuilds, getPlatforms, getProjectInfo, getProjects, getReleasesCycles, updateCycle, } from "./project.js";
 import { fetchRequirementDetails, fetchRequirements, fetchRequirementsLinkedToTestCase, } from "./requirement.js";
 import { createTestCases, fetchTestCaseDetails, fetchTestCaseExecutions, fetchTestCaseSteps, fetchTestCases, fetchTestCasesLinkedToRequirement, fetchTestCaseVersionDetails, linkRequirementToTestCase, updateTestCase, } from "./testcase.js";
-import { createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
+import { bulkUpdateExecutionStatus, createTestSuites, fetchExecutionsByTestSuite, fetchLinkedIssuesByTestCaseRun, fetchTestCaseRunsByTestSuiteRun, fetchTestCasesByTestSuite, fetchTestSuites, fetchTestSuitesForTestCase, linkPlatformsToTestSuite, linkTestCasesToTestSuite, reqLinkedTestCasesToTestSuite, updateTestSuite, } from "./testsuite.js";
 export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_PROJECTS]: getProjects,
     [QMetryToolsHandlers.SET_PROJECT_INFO]: getProjectInfo,
@@ -11,6 +12,9 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_RELEASES_CYCLES]: getReleasesCycles,
     [QMetryToolsHandlers.FETCH_BUILDS]: getBuilds,
     [QMetryToolsHandlers.FETCH_PLATFORMS]: getPlatforms,
+    [QMetryToolsHandlers.CREATE_RELEASE]: createRelease,
+    [QMetryToolsHandlers.CREATE_CYCLE]: createCycle,
+    [QMetryToolsHandlers.UPDATE_CYCLE]: updateCycle,
     [QMetryToolsHandlers.CREATE_TEST_CASE]: createTestCases,
     [QMetryToolsHandlers.UPDATE_TEST_CASE]: updateTestCase,
     [QMetryToolsHandlers.FETCH_TEST_CASES]: fetchTestCases,
@@ -31,6 +35,7 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.REQUIREMENTS_LINKED_TESTCASES_TO_TESTSUITE]: reqLinkedTestCasesToTestSuite,
     [QMetryToolsHandlers.FETCH_TESTCASES_BY_TESTSUITE]: fetchTestCasesByTestSuite,
     [QMetryToolsHandlers.FETCH_EXECUTIONS_BY_TESTSUITE]: fetchExecutionsByTestSuite,
+    [QMetryToolsHandlers.BULK_UPDATE_EXECUTION_STATUS]: bulkUpdateExecutionStatus,
     [QMetryToolsHandlers.FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN]: fetchTestCaseRunsByTestSuiteRun,
     [QMetryToolsHandlers.FETCH_LINKED_ISSUES_BY_TESTCASE_RUN]: fetchLinkedIssuesByTestCaseRun,
     [QMetryToolsHandlers.FETCH_ISSUES_LINKED_TO_TESTCASE]: fetchIssuesLinkedToTestCase,
@@ -39,4 +44,6 @@ export const QMETRY_HANDLER_MAP = {
     [QMetryToolsHandlers.FETCH_ISSUES]: fetchIssues,
     [QMetryToolsHandlers.LINK_ISSUES_TO_TESTCASE_RUN]: linkIssuesToTestcaseRun,
     [QMetryToolsHandlers.LINK_PLATFORMS_TO_TESTSUITE]: linkPlatformsToTestSuite,
+    [QMetryToolsHandlers.IMPORT_AUTOMATION_RESULTS]: importAutomationResults,
+    [QMetryToolsHandlers.FETCH_AUTOMATION_STATUS]: getAutomationStatus,
 };

package/dist/qmetry/client/project.js

@@ -1,7 +1,8 @@
 import { QMETRY_DEFAULTS } from "../config/constants.js";
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, DEFAULT_FETCH_PROJECTS_PAYLOAD, } from "../types/project.js";
+import { DEFAULT_CREATE_CYCLE_PAYLOAD, DEFAULT_CREATE_RELEASE_PAYLOAD, DEFAULT_FETCH_BUILD_PAYLOAD, DEFAULT_FETCH_PLATFORMS_PAYLOAD, DEFAULT_FETCH_PROJECTS_PAYLOAD, } from "../types/project.js";
 import { qmetryRequest } from "./api/client-api.js";
+import { resolveDefaults } from "./utils.js";
 /**
  * Retrieves project information from QMetry
  *
@@ -98,3 +99,88 @@ export async function getPlatforms(token, baseUrl, project, payload) {
         body,
     });
 }
+/**
+ * Creates a new release in QMetry with optional cycle
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key
+ * @param payload - Release and cycle data
+ * @returns Promise resolving to the created release information
+ */
+export async function createRelease(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_RELEASE_PAYLOAD,
+        ...payload,
+    };
+    if (typeof body.release.name !== "string") {
+        throw new Error("[createRelease] Missing or invalid required parameter: 'release.name'.");
+    }
+    if (body.cycle && typeof body.cycle.name !== "string") {
+        throw new Error("[createRelease] Missing or invalid required parameter: 'cycle.name'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.CREATE_RELEASE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Creates a new cycle within an existing release in QMetry
+ *
+ * @param token - QMetry API authentication token
+ * @param baseUrl - QMetry instance base URL
+ * @param project - Project key
+ * @param payload - Cycle data including releaseID
+ * @returns Promise resolving to the created cycle information
+ */
+export async function createCycle(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_CREATE_CYCLE_PAYLOAD.cycle,
+        ...payload,
+    };
+    if (typeof body.cycle.name !== "string") {
+        throw new Error("[createCycle] Missing or invalid required parameter: 'cycle.name'.");
+    }
+    if (typeof body.cycle.releaseID !== "number") {
+        throw new Error("[createCycle] Missing or invalid required parameter: 'cycle.releaseID'.");
+    }
+    return qmetryRequest({
+        method: "POST",
+        path: QMETRY_PATHS.PROJECT.CREATE_CYCLE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}
+/**
+ * Updates an existing cycle in QMetry
+ * @param token - QMetry API token
+ * @param baseUrl - QMetry base URL
+ * @param project - Project key
+ * @param payload - Cycle data including buildID and releaseID for identification
+ * @returns Promise resolving to the updated cycle information
+ */
+export async function updateCycle(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    if (typeof payload.cycle.buildID !== "number") {
+        throw new Error("[updateCycle] Missing or invalid required parameter: 'cycle.buildID'.");
+    }
+    if (typeof payload.cycle.releaseID !== "number") {
+        throw new Error("[updateCycle] Missing or invalid required parameter: 'cycle.releaseID'.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.PROJECT.UPDATE_CYCLE,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body: payload,
+    });
+}

package/dist/qmetry/client/testsuite.js

@@ -1,5 +1,5 @@
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
-import { DEFAULT_CREATE_TESTSUITE_PAYLOAD, DEFAULT_FETCH_EXECUTIONS_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_LINKED_ISSUES_BY_TESTCASE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASES_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_FOR_TESTCASE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_PAYLOAD, DEFAULT_LINKED_PLATFORMS_TO_TESTSUITE_PAYLOAD, DEFAULT_LINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_REQLINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_UPDATE_TESTSUITE_PAYLOAD, } from "../types/testsuite.js";
+import { DEFAULT_BULK_UPDATE_EXECUTION_STATUS_PAYLOAD, DEFAULT_CREATE_TESTSUITE_PAYLOAD, DEFAULT_FETCH_EXECUTIONS_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_LINKED_ISSUES_BY_TESTCASE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASE_RUNS_BY_TESTSUITE_RUN_PAYLOAD, DEFAULT_FETCH_TESTCASES_BY_TESTSUITE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_FOR_TESTCASE_PAYLOAD, DEFAULT_FETCH_TESTSUITES_PAYLOAD, DEFAULT_LINKED_PLATFORMS_TO_TESTSUITE_PAYLOAD, DEFAULT_LINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_REQLINKED_TESTCASE_TO_TESTSUITE_PAYLOAD, DEFAULT_UPDATE_TESTSUITE_PAYLOAD, } from "../types/testsuite.js";
 import { qmetryRequest } from "./api/client-api.js";
 import { resolveDefaults } from "./utils.js";
 /**
@@ -270,3 +270,39 @@ export async function linkPlatformsToTestSuite(token, baseUrl, project, payload)
         body,
     });
 }
+/**
+ * Bulk update execution status for test case runs.
+ * @throws If `entityIDs`, `entityType`, `qmTsRunId`, or `runStatusID` are missing/invalid.
+ */
+export async function bulkUpdateExecutionStatus(token, baseUrl, project, payload) {
+    const { resolvedBaseUrl, resolvedProject } = resolveDefaults(baseUrl, project);
+    const body = {
+        ...DEFAULT_BULK_UPDATE_EXECUTION_STATUS_PAYLOAD,
+        ...payload,
+    };
+    if (!body.entityIDs ||
+        typeof body.entityIDs !== "string" ||
+        body.entityIDs.trim().length === 0) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'entityIDs'. It must be a non-empty comma-separated string of Test Case Run IDs.");
+    }
+    if (!body.entityType ||
+        (body.entityType !== "TCR" && body.entityType !== "TCSR")) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'entityType'. Must be 'TCR' or 'TCSR'.");
+    }
+    if (!body.qmTsRunId ||
+        typeof body.qmTsRunId !== "string" ||
+        body.qmTsRunId.trim().length === 0) {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'qmTsRunId'. It must be a non-empty string.");
+    }
+    if (typeof body.runStatusID !== "number") {
+        throw new Error("[bulkUpdateExecutionStatus] Missing or invalid required parameter: 'runStatusID'. It must be a number.");
+    }
+    return qmetryRequest({
+        method: "PUT",
+        path: QMETRY_PATHS.TESTSUITE.BULK_UPDATE_EXECUTION_STATUS,
+        token,
+        project: resolvedProject,
+        baseUrl: resolvedBaseUrl,
+        body,
+    });
+}