fix(testmanagement): apply case_type on createTestCase

createTestCase never accepted case_type as an input, so values passed by
clients were silently dropped and the project default ("Other") was
applied. Add case_type to the schema and normalize it alongside priority
via a single form-fields lookup, matching updateTestCase behavior.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: SavioBS629

src/tools/testmanagement-utils/create-testcase.ts

@@ -43,6 +43,7 @@ export interface TestCaseCreateRequest {
   custom_fields?: Record<string, CustomFieldValue>;
   automation_status?: string;
   priority?: string;
+  case_type?: string;
   template?: string;
   template_id?: number;
 }
@@ -158,6 +159,12 @@ export const CreateTestCaseSchema = z.object({
     .describe(
       "Priority of the test case. Accepts either display name (e.g. 'Critical', 'High', 'Medium', 'Low') or internal name (e.g. 'medium'). If omitted, the project default (usually 'Medium') is applied. Valid values are per-project and discoverable via the form-fields endpoint.",
     ),
+  case_type: z
+    .string()
+    .optional()
+    .describe(
+      "Test case type. Accepts either display name (e.g. 'Functional', 'Regression', 'Smoke & Sanity') or internal name (e.g. 'functional', 'smoke_sanity'). If omitted, the project default (usually 'Other') is applied. Valid values are per-project.",
+    ),
   template: z
     .string()
     .optional()
@@ -197,33 +204,45 @@ export function sanitizeArgs(args: any) {
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
 
 /**
- * Normalize priority to the display name the create endpoint accepts (it
- * rejects lowercase). On lookup failure, pass the raw value through.
+ * Normalize priority and case_type to the display names the create endpoint
+ * accepts (it rejects lowercase internal names). Fetches the project's
+ * form-fields once; on lookup failure, passes raw values through.
  */
-async function normalizePriority(
+async function normalizeDefaultFields(
   projectIdentifier: string,
-  priority: string,
+  fields: { priority?: string; case_type?: string },
   config: BrowserStackConfig,
-): Promise<string> {
+): Promise<{ priority?: string; case_type?: string }> {
   try {
     const numericProjectId = await projectIdentifierToId(
       projectIdentifier,
       config,
     );
     const { default_fields } = await fetchFormFields(numericProjectId, config);
-    return (
-      normalizeDefaultFieldValue(
-        default_fields?.priority?.values ?? [],
-        priority,
-        "name",
-      ) ?? priority
-    );
+    const out: { priority?: string; case_type?: string } = {};
+    if (fields.priority !== undefined) {
+      out.priority =
+        normalizeDefaultFieldValue(
+          default_fields?.priority?.values ?? [],
+          fields.priority,
+          "name",
+        ) ?? fields.priority;
+    }
+    if (fields.case_type !== undefined) {
+      out.case_type =
+        normalizeDefaultFieldValue(
+          default_fields?.case_type?.values ?? [],
+          fields.case_type,
+          "name",
+        ) ?? fields.case_type;
+    }
+    return out;
   } catch (err) {
     logger.warn(
-      "Failed to normalize priority value; passing through as given: %s",
+      "Failed to normalize default fields; passing through as given: %s",
       err instanceof Error ? err.message : String(err),
     );
-    return priority;
+    return { priority: fields.priority, case_type: fields.case_type };
   }
 }
 
@@ -318,12 +337,22 @@ export async function createTestCase(
 ): Promise<CallToolResult> {
   const testCaseParams: TestCaseCreateRequest = { ...params };
 
-  if (testCaseParams.priority !== undefined) {
-    testCaseParams.priority = await normalizePriority(
+  if (
+    testCaseParams.priority !== undefined ||
+    testCaseParams.case_type !== undefined
+  ) {
+    const normalized = await normalizeDefaultFields(
       params.project_identifier,
-      testCaseParams.priority,
+      {
+        priority: testCaseParams.priority,
+        case_type: testCaseParams.case_type,
+      },
       config,
     );
+    if (normalized.priority !== undefined)
+      testCaseParams.priority = normalized.priority;
+    if (normalized.case_type !== undefined)
+      testCaseParams.case_type = normalized.case_type;
   }
 
   const authString = getBrowserStackAuth(config);

tests/tools/testmanagement.test.ts

@@ -1162,6 +1162,76 @@ describe('createTestCase — priority normalization', () => {
     const body = (apiClientMock.post as Mock).mock.calls[0][0].body;
     expect(body.test_case.priority).toBe('critical');
   });
+
+  const caseTypeValues = [
+    { name: 'Functional', internal_name: 'functional', value: 1 },
+    { name: 'Regression', internal_name: 'regression', value: 2 },
+  ];
+
+  it('looks up the project form fields and sends the normalized case_type in the request body', async () => {
+    fetchFormFieldsMock.mockResolvedValue({
+      default_fields: { case_type: { values: caseTypeValues } },
+      custom_fields: {},
+    });
+    normalizeMock.mockReturnValue('Functional');
+    (apiClientMock.post as Mock).mockResolvedValueOnce(createSuccess);
+
+    const result = await createTestCaseReal(
+      { ...baseArgs, case_type: 'functional' },
+      mockConfig as any,
+    );
+
+    expect(result.isError).toBeFalsy();
+    expect(normalizeMock).toHaveBeenCalledWith(caseTypeValues, 'functional', 'name');
+    const body = (apiClientMock.post as Mock).mock.calls[0][0].body;
+    expect(body.test_case.case_type).toBe('Functional');
+  });
+
+  it('omits case_type from the request body when not provided (preserves project default)', async () => {
+    (apiClientMock.post as Mock).mockResolvedValueOnce(createSuccess);
+
+    await createTestCaseReal({ ...baseArgs }, mockConfig as any);
+
+    const body = (apiClientMock.post as Mock).mock.calls[0][0].body;
+    expect(body.test_case).not.toHaveProperty('case_type');
+  });
+
+  it('passes the raw case_type through when the form-fields lookup fails (graceful fallback)', async () => {
+    fetchFormFieldsMock.mockRejectedValue(new Error('Network Error'));
+    (apiClientMock.post as Mock).mockResolvedValueOnce(createSuccess);
+
+    await createTestCaseReal(
+      { ...baseArgs, case_type: 'functional' },
+      mockConfig as any,
+    );
+
+    const body = (apiClientMock.post as Mock).mock.calls[0][0].body;
+    expect(body.test_case.case_type).toBe('functional');
+  });
+
+  it('normalizes both priority and case_type in a single form-fields lookup', async () => {
+    fetchFormFieldsMock.mockResolvedValue({
+      default_fields: {
+        priority: { values: priorityValues },
+        case_type: { values: caseTypeValues },
+      },
+      custom_fields: {},
+    });
+    normalizeMock.mockImplementation((_values, input) =>
+      input === 'critical' ? 'Critical' : 'Functional',
+    );
+    (apiClientMock.post as Mock).mockResolvedValueOnce(createSuccess);
+
+    await createTestCaseReal(
+      { ...baseArgs, priority: 'critical', case_type: 'functional' },
+      mockConfig as any,
+    );
+
+    expect(fetchFormFieldsMock).toHaveBeenCalledTimes(1);
+    const body = (apiClientMock.post as Mock).mock.calls[0][0].body;
+    expect(body.test_case.priority).toBe('Critical');
+    expect(body.test_case.case_type).toBe('Functional');
+  });
 });
 
 // Template slug pass-through + multi-select custom fields.