zephyr-scale-mcp-server 0.0.5 → 0.1.1

package/README.md

@@ -60,6 +60,8 @@ Then configure:
 - `delete_test_case` - Delete a specific test case
 - `create_folder` - Create a new folder in Zephyr Scale
 - `get_test_run_cases` - Get test case keys from a test run
+- `create_test_run` - Create a new test run
+- `get_test_run` - Get detailed information about a specific test run
 
 ## Examples
 
@@ -103,7 +105,23 @@ Then configure:
 }
 ```
 
+### Create Test Run
+```json
+{
+  "project_key": "PROJ",
+  "name": "Sprint 1 Test Run",
+  "test_case_keys": ["PROJ-T123", "PROJ-T124", "PROJ-T125"],
+  "environment": "Production",
+  "description": "Testing core functionality for Sprint 1"
+}
+```
 
+### Get Test Run
+```json
+{
+  "test_run_key": "PROJ-R456"
+}
+```
 
 ## Authentication
 

package/build/index.js

@@ -249,6 +249,75 @@ class ZephyrServer {
                         required: ['test_case_key'],
                     },
                 },
+                {
+                    name: 'create_test_run',
+                    description: 'Create a new test run',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            project_key: {
+                                type: 'string',
+                                description: 'Project key (required)',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Test run name (required)',
+                            },
+                            test_case_keys: {
+                                type: 'array',
+                                description: 'Array of test case keys to include in the test run',
+                                items: { type: 'string' }
+                            },
+                            test_plan_key: {
+                                type: 'string',
+                                description: 'Test plan key to link this test run to (optional)',
+                            },
+                            folder: {
+                                type: 'string',
+                                description: 'Folder path (optional)',
+                            },
+                            planned_start_date: {
+                                type: 'string',
+                                description: 'Planned start date in ISO format (optional)',
+                            },
+                            planned_end_date: {
+                                type: 'string',
+                                description: 'Planned end date in ISO format (optional)',
+                            },
+                            description: {
+                                type: 'string',
+                                description: 'Test run description (optional)',
+                            },
+                            owner: {
+                                type: 'string',
+                                description: 'Test run owner (optional)',
+                            },
+                            environment: {
+                                type: 'string',
+                                description: 'Test environment (optional)',
+                            },
+                            custom_fields: {
+                                type: 'object',
+                                description: 'Custom fields object (optional)',
+                            },
+                        },
+                        required: ['project_key', 'name'],
+                    },
+                },
+                {
+                    name: 'get_test_run',
+                    description: 'Get detailed information about a specific test run',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            test_run_key: {
+                                type: 'string',
+                                description: 'Test run key (e.g., PROJ-R123)',
+                            },
+                        },
+                        required: ['test_run_key'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -268,6 +337,10 @@ class ZephyrServer {
                         return await this.getTestRunCases(request.params.arguments);
                     case 'delete_test_case':
                         return await this.deleteTestCase(request.params.arguments);
+                    case 'create_test_run':
+                        return await this.createTestRun(request.params.arguments);
+                    case 'get_test_run':
+                        return await this.getTestRun(request.params.arguments);
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }
@@ -605,6 +678,110 @@ class ZephyrServer {
             throw new McpError(ErrorCode.InternalError, `Failed to delete test case: ${errorMessage}`);
         }
     }
+    async createTestRun(args) {
+        const { project_key, name, test_case_keys, test_plan_key, folder, planned_start_date, planned_end_date, description, owner, environment, custom_fields } = args;
+        // Build the basic payload
+        const payload = {
+            projectKey: project_key,
+            name: name,
+        };
+        // Add optional fields
+        if (test_case_keys && test_case_keys.length > 0) {
+            payload.items = test_case_keys.map((testCaseKey) => ({
+                testCaseKey: testCaseKey
+            }));
+        }
+        if (folder)
+            payload.folder = folder;
+        if (planned_start_date)
+            payload.plannedStartDate = planned_start_date;
+        if (planned_end_date)
+            payload.plannedEndDate = planned_end_date;
+        if (description)
+            payload.description = description;
+        if (owner)
+            payload.owner = owner;
+        if (environment)
+            payload.environment = environment;
+        if (custom_fields)
+            payload.customFields = custom_fields;
+        if (test_plan_key)
+            payload.testPlanKey = test_plan_key;
+        try {
+            const response = await this.axiosInstance.post('/rest/atm/1.0/testrun', payload);
+            if (response.status === 201) {
+                const testRunKey = response.data.key || 'Unknown';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Test run created successfully: ${testRunKey}\n${JSON.stringify({
+                                key: testRunKey,
+                                name: name,
+                                testCaseCount: test_case_keys?.length || 0,
+                                environment: environment || 'Not specified'
+                            }, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Unexpected status code: ${response.status}`);
+            }
+        }
+        catch (error) {
+            let errorMessage = 'Unknown error';
+            if (error instanceof Error && 'response' in error) {
+                const axiosError = error;
+                errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to create test run: ${errorMessage}`);
+        }
+    }
+    async getTestRun(args) {
+        const { test_run_key } = args;
+        try {
+            const response = await this.axiosInstance.get(`/rest/atm/1.0/testrun/${test_run_key}`);
+            if (response.status === 200) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(response.data, null, 2),
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new Error(`Failed to retrieve test run: ${response.status}`);
+            }
+        }
+        catch (error) {
+            let errorMessage = 'Unknown error';
+            if (error instanceof Error && 'response' in error) {
+                const axiosError = error;
+                if (axiosError.response?.status === 404) {
+                    errorMessage = `Test run ${test_run_key} not found`;
+                }
+                else {
+                    errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+                }
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to get test run: ${errorMessage}`);
+        }
+    }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zephyr-scale-mcp-server",
-  "version": "0.0.5",
+  "version": "0.1.1",
   "description": "Model Context Protocol (MCP) server for Zephyr Scale test case management with comprehensive STEP_BY_STEP, PLAIN_TEXT, and BDD support",
   "type": "module",
   "main": "./build/index.js",

package/src/index.ts

@@ -266,6 +266,75 @@ class ZephyrServer {
             required: ['test_case_key'],
           },
         },
+        {
+          name: 'create_test_run',
+          description: 'Create a new test run',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              project_key: {
+                type: 'string',
+                description: 'Project key (required)',
+              },
+              name: {
+                type: 'string',
+                description: 'Test run name (required)',
+              },
+              test_case_keys: {
+                type: 'array',
+                description: 'Array of test case keys to include in the test run',
+                items: { type: 'string' }
+              },
+              test_plan_key: {
+                type: 'string',
+                description: 'Test plan key to link this test run to (optional)',
+              },
+              folder: {
+                type: 'string',
+                description: 'Folder path (optional)',
+              },
+              planned_start_date: {
+                type: 'string',
+                description: 'Planned start date in ISO format (optional)',
+              },
+              planned_end_date: {
+                type: 'string',
+                description: 'Planned end date in ISO format (optional)',
+              },
+              description: {
+                type: 'string',
+                description: 'Test run description (optional)',
+              },
+              owner: {
+                type: 'string',
+                description: 'Test run owner (optional)',
+              },
+              environment: {
+                type: 'string',
+                description: 'Test environment (optional)',
+              },
+              custom_fields: {
+                type: 'object',
+                description: 'Custom fields object (optional)',
+              },
+            },
+            required: ['project_key', 'name'],
+          },
+        },
+        {
+          name: 'get_test_run',
+          description: 'Get detailed information about a specific test run',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              test_run_key: {
+                type: 'string',
+                description: 'Test run key (e.g., PROJ-R123)',
+              },
+            },
+            required: ['test_run_key'],
+          },
+        },
       ],
     }));
 
@@ -286,6 +355,10 @@ class ZephyrServer {
             return await this.getTestRunCases(request.params.arguments);
           case 'delete_test_case':
             return await this.deleteTestCase(request.params.arguments);
+          case 'create_test_run':
+            return await this.createTestRun(request.params.arguments);
+          case 'get_test_run':
+            return await this.getTestRun(request.params.arguments);
           default:
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
         }
@@ -660,6 +733,119 @@ class ZephyrServer {
     }
   }
 
+  private async createTestRun(args: any) {
+    const { 
+      project_key, 
+      name, 
+      test_case_keys,
+      test_plan_key,
+      folder,
+      planned_start_date,
+      planned_end_date,
+      description,
+      owner,
+      environment,
+      custom_fields
+    } = args;
+    
+    // Build the basic payload
+    const payload: any = {
+      projectKey: project_key,
+      name: name,
+    };
+    
+    // Add optional fields
+    if (test_case_keys && test_case_keys.length > 0) {
+      payload.items = test_case_keys.map((testCaseKey: string) => ({
+        testCaseKey: testCaseKey
+      }));
+    }
+    if (folder) payload.folder = folder;
+    if (planned_start_date) payload.plannedStartDate = planned_start_date;
+    if (planned_end_date) payload.plannedEndDate = planned_end_date;
+    if (description) payload.description = description;
+    if (owner) payload.owner = owner;
+    if (environment) payload.environment = environment;
+    if (custom_fields) payload.customFields = custom_fields;
+    if (test_plan_key) payload.testPlanKey = test_plan_key;
+    
+    try {
+      const response = await this.axiosInstance.post('/rest/atm/1.0/testrun', payload);
+      
+      if (response.status === 201) {
+        const testRunKey = response.data.key || 'Unknown';
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Test run created successfully: ${testRunKey}\n${JSON.stringify({ 
+                key: testRunKey,
+                name: name,
+                testCaseCount: test_case_keys?.length || 0,
+                environment: environment || 'Not specified'
+              }, null, 2)}`,
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Unexpected status code: ${response.status}`);
+      }
+    } catch (error) {
+      let errorMessage = 'Unknown error';
+      if (error instanceof Error && 'response' in error) {
+        const axiosError = error as any;
+        errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = String(error);
+      }
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to create test run: ${errorMessage}`
+      );
+    }
+  }
+
+  private async getTestRun(args: any) {
+    const { test_run_key } = args;
+    
+    try {
+      const response = await this.axiosInstance.get(`/rest/atm/1.0/testrun/${test_run_key}`);
+      
+      if (response.status === 200) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(response.data, null, 2),
+            },
+          ],
+        };
+      } else {
+        throw new Error(`Failed to retrieve test run: ${response.status}`);
+      }
+    } catch (error) {
+      let errorMessage = 'Unknown error';
+      if (error instanceof Error && 'response' in error) {
+        const axiosError = error as any;
+        if (axiosError.response?.status === 404) {
+          errorMessage = `Test run ${test_run_key} not found`;
+        } else {
+          errorMessage = `Status: ${axiosError.response?.status}, Data: ${JSON.stringify(axiosError.response?.data)}`;
+        }
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      } else {
+        errorMessage = String(error);
+      }
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Failed to get test run: ${errorMessage}`
+      );
+    }
+  }
+
   async run() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);