Merge branch 'AIMCP-4-add-support-to-upload-prd-file' into main

Author: ruturaj-browserstack

package-lock.json

@@ -57,4 +57,4 @@
     "vite": "^6.3.5",
     "vitest": "^3.1.3"
   }
-}
+}

package.json

@@ -0,0 +1 @@
+export const signedUrlMap = new Map<string, object>();

src/lib/inmemory-store.ts

@@ -0,0 +1,363 @@
+import axios from "axios";
+import {
+  TCG_TRIGGER_URL,
+  TCG_POLL_URL,
+  FETCH_DETAILS_URL,
+  FORM_FIELDS_URL,
+  BULK_CREATE_URL,
+} from "./config";
+import {
+  DefaultFieldMaps,
+  Scenario,
+  CreateTestCasesFromFileArgs,
+} from "./types";
+import { createTestCasePayload } from "./helpers";
+import config from "../../../config";
+
+/**
+ * Fetch default and custom form fields for a project.
+ */
+export async function fetchFormFields(
+  projectId: string,
+): Promise<{ default_fields: any; custom_fields: any }> {
+  const res = await axios.get(FORM_FIELDS_URL(projectId), {
+    headers: {
+      "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+    },
+  });
+  return res.data;
+}
+
+/**
+ * Trigger AI-based test case generation for a document.
+ */
+export async function triggerTestCaseGeneration(
+  document: string,
+  documentId: number,
+  folderId: string,
+  projectId: string,
+  source: string,
+): Promise<string> {
+  const res = await axios.post(
+    TCG_TRIGGER_URL,
+    {
+      document,
+      documentId,
+      folderId,
+      projectId,
+      source,
+      webhookUrl: `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/webhooks/tcg`,
+    },
+    {
+      headers: {
+        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+        "Content-Type": "application/json",
+        "request-source": source,
+      },
+    },
+  );
+  if (res.status !== 200) {
+    throw new Error(`Trigger failed: ${res.statusText}`);
+  }
+  return res.data["x-bstack-traceRequestId"];
+}
+
+/**
+ * Initiate a fetch for test-case details; returns the traceRequestId for polling.
+ */
+export async function fetchTestCaseDetails(
+  documentId: number,
+  folderId: string,
+  projectId: string,
+  testCaseIds: string[],
+  source: string,
+): Promise<string> {
+  if (testCaseIds.length === 0) {
+    throw new Error("No testCaseIds provided to fetchTestCaseDetails");
+  }
+  const res = await axios.post(
+    FETCH_DETAILS_URL,
+    {
+      document_id: documentId,
+      folder_id: folderId,
+      project_id: projectId,
+      test_case_ids: testCaseIds,
+    },
+    {
+      headers: {
+        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+        "request-source": source,
+        "Content-Type": "application/json",
+      },
+    },
+  );
+  if (res.data.data.success !== true) {
+    throw new Error(`Fetch details failed: ${res.data.data.message}`);
+  }
+  return res.data.request_trace_id;
+}
+
+/**
+ * Poll for a given traceRequestId until all test-case details are returned.
+ */
+export async function pollTestCaseDetails(
+  traceRequestId: string,
+): Promise<Record<string, any>> {
+  const detailMap: Record<string, any> = {};
+  let done = false;
+
+  while (!done) {
+    // add a bit of jitter to avoid synchronized polling storms
+    await new Promise((r) => setTimeout(r, 10000 + Math.random() * 5000));
+
+    const poll = await axios.post(
+      `${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(
+        traceRequestId,
+      )}`,
+      {},
+      {
+        headers: {
+          "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+        },
+      },
+    );
+
+    if (!poll.data.data.success) {
+      throw new Error(`Polling failed: ${poll.data.data.message}`);
+    }
+
+    for (const msg of poll.data.data.message) {
+      if (msg.type === "termination") {
+        done = true;
+      }
+      if (msg.type === "testcase_details") {
+        for (const test of msg.data.testcase_details) {
+          detailMap[test.id] = {
+            steps: test.steps,
+            preconditions: test.preconditions,
+          };
+        }
+      }
+    }
+  }
+
+  return detailMap;
+}
+
+/**
+ * Poll for scenarios & testcases, trigger detail fetches, then poll all details in parallel.
+ */
+export async function pollScenariosTestDetails(
+  args: CreateTestCasesFromFileArgs,
+  traceId: string,
+  context: any,
+  documentId: number,
+  source: string,
+): Promise<Record<string, Scenario>> {
+  const { folderId, projectReferenceId } = args;
+  const scenariosMap: Record<string, Scenario> = {};
+  const detailPromises: Promise<Record<string, any>>[] = [];
+  let iteratorCount = 0;
+
+  // Promisify interval-style polling using a wrapper
+  await new Promise<void>((resolve, reject) => {
+    const intervalId = setInterval(async () => {
+      try {
+        const poll = await axios.post(
+          `${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`,
+          {},
+          {
+            headers: {
+              "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            },
+          },
+        );
+
+        if (poll.status !== 200) {
+          clearInterval(intervalId);
+          reject(new Error(`Polling error: ${poll.statusText}`));
+          return;
+        }
+
+        for (const msg of poll.data.data.message) {
+          if (msg.type === "scenario") {
+            msg.data.scenarios.forEach((sc: any) => {
+              scenariosMap[sc.id] = { id: sc.id, name: sc.name, testcases: [] };
+            });
+            const count = Object.keys(scenariosMap).length;
+            await context.sendNotification({
+              method: "notifications/progress",
+              params: {
+                progressToken: context._meta?.progressToken ?? traceId,
+                progress: count,
+                total: count,
+                message: `Fetched ${count} scenarios`,
+              },
+            });
+          }
+
+          if (msg.type === "testcase") {
+            const sc = msg.data.scenario;
+            if (sc) {
+              const array = Array.isArray(msg.data.testcases)
+                ? msg.data.testcases
+                : msg.data.testcases
+                  ? [msg.data.testcases]
+                  : [];
+              const ids = array.map((tc: any) => tc.id || tc.test_case_id);
+
+              const reqId = await fetchTestCaseDetails(
+                documentId,
+                folderId,
+                projectReferenceId,
+                ids,
+                source,
+              );
+              detailPromises.push(pollTestCaseDetails(reqId));
+
+              scenariosMap[sc.id] ||= {
+                id: sc.id,
+                name: sc.name,
+                testcases: [],
+                traceId,
+              };
+              scenariosMap[sc.id].testcases.push(...array);
+              iteratorCount++;
+              const total = Object.keys(scenariosMap).length;
+              await context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                  progressToken: context._meta?.progressToken ?? traceId,
+                  progress: iteratorCount,
+                  total,
+                  message: `Fetched ${array.length} test cases for scenario ${iteratorCount} out of ${total}`,
+                },
+              });
+            }
+          }
+
+          if (msg.type === "termination") {
+            clearInterval(intervalId);
+            resolve();
+          }
+        }
+      } catch (err) {
+        clearInterval(intervalId);
+        reject(err);
+      }
+    }, 10000); // 10 second interval
+  });
+
+  // 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)) {
+    scenario.testcases = scenario.testcases.map((tc: any) => ({
+      ...tc,
+      ...(allDetails[tc.id || tc.test_case_id] ?? {}),
+    }));
+  }
+
+  return scenariosMap;
+}
+
+/**
+ * Bulk-create generated test cases in BrowserStack.
+ */
+export async function bulkCreateTestCases(
+  scenariosMap: Record<string, Scenario>,
+  projectId: string,
+  folderId: string,
+  fieldMaps: DefaultFieldMaps,
+  booleanFieldId: number | undefined,
+  traceId: string,
+  context: any,
+  documentId: number,
+): Promise<string> {
+  const results: Record<string, any> = {};
+  const total = Object.keys(scenariosMap).length;
+  let doneCount = 0;
+  let testCaseCount = 0;
+
+  for (const { id, testcases } of Object.values(scenariosMap)) {
+    const testCaseLength = testcases.length;
+    testCaseCount += testCaseLength;
+    if (testCaseLength === 0) continue;
+    const payload = {
+      test_cases: testcases.map((tc) =>
+        createTestCasePayload(
+          tc,
+          id,
+          folderId,
+          fieldMaps,
+          documentId,
+          booleanFieldId,
+          traceId,
+        ),
+      ),
+    };
+
+    try {
+      const resp = await axios.post(
+        BULK_CREATE_URL(projectId, folderId),
+        payload,
+        {
+          headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "Content-Type": "application/json",
+          },
+        },
+      );
+      results[id] = resp.data;
+      await context.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken: context._meta?.progressToken ?? "bulk-create",
+          message: `Bulk create done for scenario ${doneCount} of ${total}`,
+          total,
+          progress: doneCount,
+        },
+      });
+    } catch (error) {
+      //send notification
+      await context.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken: context._meta?.progressToken ?? traceId,
+          message: `Bulk create failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          total,
+          progress: doneCount,
+        },
+      });
+      //continue to next scenario
+      continue;
+    }
+    doneCount++;
+  }
+  const resultString = `Total of ${testCaseCount} test cases created in ${total} scenarios.`;
+  return resultString;
+}
+
+export async function projectIdentifierToId(
+  projectId: string,
+): Promise<string> {
+  const url = `https://test-management.browserstack.com/api/v1/projects/?q=${projectId}`;
+
+  const response = await axios.get(url, {
+    headers: {
+      "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+      accept: "application/json, text/plain, */*",
+    },
+  });
+  if (response.data.success !== true) {
+    throw new Error(`Failed to fetch project ID: ${response.statusText}`);
+  }
+  for (const project of response.data.projects) {
+    if (project.identifier === projectId) {
+      return project.id;
+    }
+  }
+  throw new Error(`Project with identifier ${projectId} not found.`);
+}

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

@@ -0,0 +1,10 @@
+export const TCG_TRIGGER_URL =
+  "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/suggest-test-cases";
+export const TCG_POLL_URL =
+  "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/test-cases-polling";
+export const FETCH_DETAILS_URL =
+  "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/fetch-test-case-details";
+export const FORM_FIELDS_URL = (projectId: string): string =>
+  `https://test-management.browserstack.com/api/v1/projects/${projectId}/form-fields-v2`;
+export const BULK_CREATE_URL = (projectId: string, folderId: string): string =>
+  `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/bulk-test-cases`;