fix: cap test cases per scenario to backend per-request limit

Author: SavioBS629

src/lib/apiClient.ts

@@ -150,18 +150,8 @@ class ApiClient {
       const res = await fn(this.axiosAgent);
       return new ApiResponse<T>(res);
     } catch (error: any) {
-      if (error.response) {
-        if (!raise_error) {
-          return new ApiResponse<T>(error.response);
-        }
-        const body = error.response.data;
-        const serverMessage =
-          typeof body === "string"
-            ? body
-            : (body?.message ?? body?.error ?? JSON.stringify(body));
-        if (serverMessage) {
-          error.message = `Request failed with status code ${error.response.status}: ${serverMessage}`;
-        }
+      if (error.response && !raise_error) {
+        return new ApiResponse<T>(error.response);
       }
       throw error;
     }

src/tools/testmanagement-utils/TCG-utils/api.ts

@@ -6,26 +6,16 @@ import {
   FORM_FIELDS_URL,
   BULK_CREATE_URL,
   TC_DETAILS_MAX_BATCH,
-  BULK_CREATE_MAX_BATCH,
-  MAX_SCENARIOS_PER_DOCUMENT,
 } from "./config.js";
 import {
   DefaultFieldMaps,
   Scenario,
   CreateTestCasesFromFileArgs,
 } from "./types.js";
-import {
-  createTestCasePayload,
-  chunkArray,
-  canAcceptScenario,
-} from "./helpers.js";
+import { createTestCasePayload } from "./helpers.js";
 import { getBrowserStackAuth } from "../../../lib/get-auth.js";
 import { BrowserStackConfig } from "../../../lib/types.js";
 import { getTMBaseURL } from "../../../lib/tm-base-url.js";
-import logger from "../../../logger.js";
-
-const POLL_INTERVAL_MS = 10000;
-const MAX_POLL_DURATION_MS = 8 * 60 * 1000;
 
 /**
  * Fetch default and custom form fields for a project.
@@ -143,7 +133,6 @@ export async function fetchTestCaseDetails(
 export async function pollTestCaseDetails(
   traceRequestId: string,
   config: BrowserStackConfig,
-  deadline: number = Date.now() + MAX_POLL_DURATION_MS,
 ): Promise<Record<string, any>> {
   const detailMap: Record<string, any> = {};
   let done = false;
@@ -152,27 +141,18 @@ export async function pollTestCaseDetails(
 
   while (!done) {
     // add a bit of jitter to avoid synchronized polling storms
-    await new Promise((r) =>
-      setTimeout(r, POLL_INTERVAL_MS + Math.random() * 5000),
-    );
-
-    // Give up before the backend key TTL expires; return whatever we collected.
-    if (Date.now() > deadline) break;
+    await new Promise((r) => setTimeout(r, 10000 + Math.random() * 5000));
 
     const poll = await apiClient.post({
       url: `${TCG_POLL_URL_VALUE}?x-bstack-traceRequestId=${encodeURIComponent(traceRequestId)}`,
       headers: {
         "API-TOKEN": getBrowserStackAuth(config),
       },
       body: {},
-      // Don't throw on a non-2xx: an expired request key returns 400
-      // ("Request ids does not exists") and simply means there is nothing more
-      // to fetch — stop gracefully instead of failing the whole run.
-      raise_error: false,
     });
 
-    if (poll.status !== 200 || !poll.data?.data?.success) {
-      break;
+    if (!poll.data.data.success) {
+      throw new Error(`Polling failed: ${poll.data.data.message}`);
     }
 
     for (const msg of poll.data.data.message) {
@@ -210,55 +190,29 @@ export async function pollScenariosTestDetails(
   let iteratorCount = 0;
   const tmBaseUrl = await getTMBaseURL(config);
   const TCG_POLL_URL_VALUE = TCG_POLL_URL(tmBaseUrl);
-  const deadline = Date.now() + MAX_POLL_DURATION_MS;
 
   // Promisify interval-style polling using a wrapper
   await new Promise<void>((resolve, reject) => {
-    let stopped = false;
-
-    const pollOnce = async () => {
-      if (stopped) return;
+    const intervalId = setInterval(async () => {
       try {
         const poll = await apiClient.post({
           url: `${TCG_POLL_URL_VALUE}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`,
           headers: {
             "API-TOKEN": getBrowserStackAuth(config),
           },
           body: {},
-          raise_error: false,
         });
 
         if (poll.status !== 200) {
-          stopped = true;
-          if (Object.keys(scenariosMap).length > 0) {
-            resolve();
-          } else {
-            reject(
-              new Error(
-                `Polling error: ${poll.status} ${typeof poll.data === "string" ? poll.data : JSON.stringify(poll.data)}`,
-              ),
-            );
-          }
+          clearInterval(intervalId);
+          reject(new Error(`Polling error: ${poll.statusText || poll.status}`));
           return;
         }
 
-        let terminated = false;
         for (const msg of poll.data.data.message) {
           if (msg.type === "scenario") {
             msg.data.scenarios.forEach((sc: any) => {
-              if (
-                canAcceptScenario(
-                  scenariosMap,
-                  sc.id,
-                  MAX_SCENARIOS_PER_DOCUMENT,
-                )
-              ) {
-                scenariosMap[sc.id] ||= {
-                  id: sc.id,
-                  name: sc.name,
-                  testcases: [],
-                };
-              }
+              scenariosMap[sc.id] = { id: sc.id, name: sc.name, testcases: [] };
             });
             const count = Object.keys(scenariosMap).length;
             await context.sendNotification({
@@ -274,32 +228,25 @@ export async function pollScenariosTestDetails(
 
           if (msg.type === "testcase") {
             const sc = msg.data.scenario;
-            if (
-              sc &&
-              canAcceptScenario(scenariosMap, sc.id, MAX_SCENARIOS_PER_DOCUMENT)
-            ) {
-              const array = Array.isArray(msg.data.testcases)
-                ? msg.data.testcases
-                : msg.data.testcases
-                  ? [msg.data.testcases]
-                  : [];
-              const ids: string[] = array.map(
-                (tc: any) => tc.id || tc.test_case_id,
+            if (sc) {
+              const array = (
+                Array.isArray(msg.data.testcases)
+                  ? msg.data.testcases
+                  : msg.data.testcases
+                    ? [msg.data.testcases]
+                    : []
+              ).slice(0, TC_DETAILS_MAX_BATCH);
+              const ids = array.map((tc: any) => tc.id || tc.test_case_id);
+
+              const reqId = await fetchTestCaseDetails(
+                documentId,
+                folderId,
+                projectReferenceId,
+                ids,
+                source,
+                config,
               );
-
-              for (const idChunk of chunkArray(ids, TC_DETAILS_MAX_BATCH)) {
-                const reqId = await fetchTestCaseDetails(
-                  documentId,
-                  folderId,
-                  projectReferenceId,
-                  idChunk,
-                  source,
-                  config,
-                );
-                detailPromises.push(
-                  pollTestCaseDetails(reqId, config, deadline),
-                );
-              }
+              detailPromises.push(pollTestCaseDetails(reqId, config));
 
               scenariosMap[sc.id] ||= {
                 id: sc.id,
@@ -323,41 +270,20 @@ export async function pollScenariosTestDetails(
           }
 
           if (msg.type === "termination") {
-            terminated = true;
+            clearInterval(intervalId);
+            resolve();
           }
         }
-
-        if (terminated || Date.now() > deadline) {
-          stopped = true;
-          logger.info(
-            `TCG scenario poll stopped (${terminated ? "termination received" : "max duration reached"}); ${Object.keys(scenariosMap).length} scenarios, ${detailPromises.length} detail fetches`,
-          );
-          resolve();
-          return;
-        }
-        setTimeout(pollOnce, POLL_INTERVAL_MS);
       } catch (err) {
-        stopped = true;
+        clearInterval(intervalId);
         reject(err);
       }
-    };
-    setTimeout(pollOnce, POLL_INTERVAL_MS);
+    }, 10000); // 10 second interval
   });
 
-  const detailsList = await Promise.allSettled(detailPromises);
-  const rejectedDetails = detailsList.filter(
-    (r) => r.status === "rejected",
-  ).length;
-  if (rejectedDetails > 0) {
-    logger.info(
-      `TCG detail fetches: ${detailsList.length - rejectedDetails}/${detailsList.length} succeeded, ${rejectedDetails} failed (degrading gracefully)`,
-    );
-  }
-  const allDetails = detailsList.reduce<Record<string, any>>(
-    (acc, result) =>
-      result.status === "fulfilled" ? { ...acc, ...result.value } : acc,
-    {},
-  );
+  // once all detail fetches are triggered, wait for them to complete
+  const detailsList = await Promise.all(detailPromises);
+  const allDetails = detailsList.reduce((acc, cur) => ({ ...acc, ...cur }), {});
 
   // attach the fetched detail objects back to each testcase
   for (const scenario of Object.values(scenariosMap)) {
@@ -384,65 +310,44 @@ export async function bulkCreateTestCases(
   documentId: number,
   config: BrowserStackConfig,
 ): Promise<string> {
+  const results: Record<string, any> = {};
   const total = Object.keys(scenariosMap).length;
   let doneCount = 0;
   let testCaseCount = 0;
-  const failedScenarios: string[] = [];
   const tmBaseUrl = await getTMBaseURL(config);
   const BULK_CREATE_URL_VALUE = BULK_CREATE_URL(tmBaseUrl, projectId, folderId);
 
   for (const { id, testcases } of Object.values(scenariosMap)) {
-    if (testcases.length === 0) continue;
-
-    const batches = chunkArray(testcases, BULK_CREATE_MAX_BATCH);
-    let createdInScenario = 0;
-    let scenarioFailed = false;
-
-    for (const batch of batches) {
-      const payload = {
-        test_cases: batch.map((tc) =>
-          createTestCasePayload(
-            tc,
-            id,
-            folderId,
-            fieldMaps,
-            documentId,
-            booleanFieldId,
-            traceId,
-          ),
+    // Cap per-scenario test cases to the backend's per-request limit so the
+    // bulk-create call never exceeds it ("More than permitted test cases sent").
+    const cappedTestcases = testcases.slice(0, TC_DETAILS_MAX_BATCH);
+    const testCaseLength = cappedTestcases.length;
+    testCaseCount += testCaseLength;
+    if (testCaseLength === 0) continue;
+    const payload = {
+      test_cases: cappedTestcases.map((tc) =>
+        createTestCasePayload(
+          tc,
+          id,
+          folderId,
+          fieldMaps,
+          documentId,
+          booleanFieldId,
+          traceId,
         ),
-      };
-
-      try {
-        await apiClient.post({
-          url: BULK_CREATE_URL_VALUE,
-          headers: {
-            "API-TOKEN": getBrowserStackAuth(config),
-            "Content-Type": "application/json",
-          },
-          body: payload,
-        });
-        createdInScenario += batch.length;
-      } catch (error) {
-        scenarioFailed = true;
-        await context.sendNotification({
-          method: "notifications/progress",
-          params: {
-            progressToken: context._meta?.progressToken ?? traceId,
-            message: `Creation failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
-            total,
-            progress: doneCount,
-          },
-        });
-      }
-    }
+      ),
+    };
 
-    testCaseCount += createdInScenario;
-    if (scenarioFailed) {
-      failedScenarios.push(id);
-    }
-    if (createdInScenario > 0) {
-      doneCount++;
+    try {
+      const resp = await apiClient.post({
+        url: BULK_CREATE_URL_VALUE,
+        headers: {
+          "API-TOKEN": getBrowserStackAuth(config),
+          "Content-Type": "application/json",
+        },
+        body: payload,
+      });
+      results[id] = resp.data;
       await context.sendNotification({
         method: "notifications/progress",
         params: {
@@ -452,12 +357,23 @@ export async function bulkCreateTestCases(
           progress: doneCount,
         },
       });
+    } catch (error) {
+      //send notification
+      await context.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken: context._meta?.progressToken ?? traceId,
+          message: `Creation failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          total,
+          progress: doneCount,
+        },
+      });
+      //continue to next scenario
+      continue;
     }
+    doneCount++;
   }
-  let resultString = `Total of ${testCaseCount} test cases created in ${doneCount} of ${total} scenarios.`;
-  if (failedScenarios.length > 0) {
-    resultString += ` Failed to create test cases for ${failedScenarios.length} scenario(s): ${failedScenarios.join(", ")}.`;
-  }
+  const resultString = `Total of ${testCaseCount} test cases created in ${total} scenarios.`;
   return resultString;
 }
 

src/tools/testmanagement-utils/TCG-utils/config.ts

@@ -1,10 +1,5 @@
 export const TC_DETAILS_MAX_BATCH = 10;
 
-export const BULK_CREATE_MAX_BATCH = 10;
-
-// Cap scenarios per document (mirrors TCG's former maxScenariosPerDocument=10).
-export const MAX_SCENARIOS_PER_DOCUMENT = 10;
-
 export const TCG_TRIGGER_URL = (baseUrl: string) =>
   `${baseUrl}/api/v1/integration/tcg/test-generation/suggest-test-cases`;