cucumberstudio-mcp 1.1.0

package/test/mocks/handlers/scenarios.ts

@@ -0,0 +1,72 @@
+import { http, HttpResponse } from 'msw'
+
+import { mockScenarios, mockScenario, mockFolders } from '../data/scenarios.js'
+
+const BASE_URL = 'https://api.example.com'
+
+export const scenarioHandlers = [
+  // List scenarios in a project
+  http.get(`${BASE_URL}/projects/:projectId/scenarios`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = Number(params.projectId)
+    const projectScenarios = mockScenarios.filter((s) => s.project_id === projectId)
+
+    // Handle query parameters for filtering
+    const url = new URL(request.url)
+    const tags = url.searchParams.get('tags')
+    const folderId = url.searchParams.get('folder_id')
+
+    let filteredScenarios = projectScenarios
+
+    if (tags) {
+      const tagList = tags.split(',')
+      filteredScenarios = filteredScenarios.filter((scenario) =>
+        tagList.some((tag) => scenario.tags.includes(tag.trim())),
+      )
+    }
+
+    if (folderId) {
+      const folderIdNum = Number(folderId)
+      filteredScenarios = filteredScenarios.filter((scenario) => scenario.folder_id === folderIdNum)
+    }
+
+    return HttpResponse.json(filteredScenarios)
+  }),
+
+  // Get specific scenario
+  http.get(`${BASE_URL}/projects/:projectId/scenarios/:id`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const scenarioId = Number(params.id)
+    const scenario = mockScenarios.find((s) => s.id === scenarioId)
+
+    if (!scenario) {
+      return HttpResponse.json({ error: 'Scenario not found' }, { status: 404 })
+    }
+
+    return HttpResponse.json(scenario)
+  }),
+
+  // List folders in a project
+  http.get(`${BASE_URL}/projects/:projectId/folders`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = Number(params.projectId)
+    const projectFolders = mockFolders.filter((f) => f.project_id === projectId)
+
+    return HttpResponse.json(projectFolders)
+  }),
+]

package/test/mocks/handlers/test-runs.ts

@@ -0,0 +1,106 @@
+import { http, HttpResponse } from 'msw'
+
+import {
+  mockTestRuns,
+  mockTestRun,
+  mockTestExecutions,
+  mockBuilds,
+  mockBuild,
+  mockExecutionEnvironments,
+} from '../data/test-runs.js'
+
+const BASE_URL = 'https://api.example.com'
+
+export const testRunHandlers = [
+  // List test runs in a project
+  http.get(`${BASE_URL}/projects/:projectId/test_runs`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = Number(params.projectId)
+    const projectTestRuns = mockTestRuns.filter((t) => t.project_id === projectId)
+
+    return HttpResponse.json(projectTestRuns)
+  }),
+
+  // Get specific test run
+  http.get(`${BASE_URL}/projects/:projectId/test_runs/:id`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const testRunId = Number(params.id)
+    const testRun = mockTestRuns.find((t) => t.id === testRunId)
+
+    if (!testRun) {
+      return HttpResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    return HttpResponse.json(testRun)
+  }),
+
+  // Get test executions for a test run
+  http.get(`${BASE_URL}/projects/:projectId/test_runs/:testRunId/test_snapshots`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const testRunId = Number(params.testRunId)
+    const executions = mockTestExecutions.filter((e) => e.test_run_id === testRunId)
+
+    return HttpResponse.json(executions)
+  }),
+
+  // List builds in a project
+  http.get(`${BASE_URL}/projects/:projectId/builds`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = Number(params.projectId)
+    const projectBuilds = mockBuilds.filter((b) => b.project_id === projectId)
+
+    return HttpResponse.json(projectBuilds)
+  }),
+
+  // Get specific build
+  http.get(`${BASE_URL}/projects/:projectId/builds/:id`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const buildId = Number(params.id)
+    const build = mockBuilds.find((b) => b.id === buildId)
+
+    if (!build) {
+      return HttpResponse.json({ error: 'Build not found' }, { status: 404 })
+    }
+
+    return HttpResponse.json(build)
+  }),
+
+  // List execution environments
+  http.get(`${BASE_URL}/projects/:projectId/execution_environments`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = Number(params.projectId)
+    const environments = mockExecutionEnvironments.filter((e) => e.project_id === projectId)
+
+    return HttpResponse.json(environments)
+  }),
+]

package/test/mocks/server.ts

@@ -0,0 +1,26 @@
+import { setupServer } from 'msw/node'
+
+import { handlers } from './handlers/index.js'
+
+// Create and export the mock server
+export const mockServer = setupServer(...handlers)
+
+// Helper functions for test setup
+export const startMockServer = () => {
+  mockServer.listen({
+    onUnhandledRequest: 'warn', // Warn about unhandled requests
+  })
+}
+
+export const stopMockServer = () => {
+  mockServer.close()
+}
+
+export const resetMockServer = () => {
+  mockServer.resetHandlers()
+}
+
+// Export handlers for selective testing
+export { handlers } from './handlers/index.js'
+export * from './handlers/index.js'
+export * from './data/index.js'

package/test/setup/vitest.setup.ts

@@ -0,0 +1,18 @@
+import { beforeAll, afterEach, afterAll } from 'vitest'
+
+import { startMockServer, stopMockServer, resetMockServer } from '../mocks/server.js'
+
+// Start the mock server before all tests
+beforeAll(() => {
+  startMockServer()
+})
+
+// Reset handlers after each test to ensure test isolation
+afterEach(() => {
+  resetMockServer()
+})
+
+// Stop the mock server after all tests
+afterAll(() => {
+  stopMockServer()
+})

package/test/tools/coverage-boost.test.ts

@@ -0,0 +1,252 @@
+import { CallToolRequest } from '@modelcontextprotocol/sdk/types.js'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+
+import { CucumberStudioApiClient } from '@/api/client.js'
+import { ActionWordTools } from '@/tools/action-words.js'
+import { ScenarioTools } from '@/tools/scenarios.js'
+import { TestRunTools } from '@/tools/test-runs.js'
+
+// Mock the API client
+vi.mock('@/api/client.js')
+
+describe('Tools Coverage Boost', () => {
+  let mockApiClient: any
+
+  beforeEach(() => {
+    mockApiClient = {
+      getScenarios: vi.fn().mockResolvedValue({ data: [] }),
+      getScenario: vi.fn().mockResolvedValue({ data: { id: 1, attributes: { name: 'Test' } } }),
+      findScenariosByTag: vi.fn().mockResolvedValue({ data: [] }),
+      getActionWords: vi.fn().mockResolvedValue({ data: [] }),
+      getActionWord: vi.fn().mockResolvedValue({ data: { id: 1, attributes: { name: 'Test' } } }),
+      findActionWordsByTag: vi.fn().mockResolvedValue({ data: [] }),
+      getTestRuns: vi.fn().mockResolvedValue({ data: [] }),
+      getTestRun: vi.fn().mockResolvedValue({ data: { id: 1, attributes: { name: 'Test' } } }),
+      getTestExecutions: vi.fn().mockResolvedValue({ data: [] }),
+      getBuilds: vi.fn().mockResolvedValue({ data: [] }),
+      getBuild: vi.fn().mockResolvedValue({ data: { id: 1, attributes: { name: 'Test' } } }),
+      getExecutionEnvironments: vi.fn().mockResolvedValue({ data: [] }),
+    }
+  })
+
+  describe('ScenarioTools handleToolCall', () => {
+    let scenarioTools: ScenarioTools
+
+    beforeEach(() => {
+      scenarioTools = new ScenarioTools(mockApiClient)
+    })
+
+    it('should handle cucumberstudio_list_scenarios', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_scenarios',
+          arguments: { projectId: '1' },
+        },
+      }
+
+      const result = await scenarioTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+      expect(result.content[0].type).toBe('text')
+    })
+
+    it('should handle cucumberstudio_get_scenario', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_get_scenario',
+          arguments: { projectId: '1', scenarioId: '1' },
+        },
+      }
+
+      const result = await scenarioTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_find_scenarios_by_tags', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_find_scenarios_by_tags',
+          arguments: { projectId: '1', tags: 'test' },
+        },
+      }
+
+      const result = await scenarioTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    // Note: cucumberstudio_list_folders is not implemented in ScenarioTools
+
+    it('should throw for unknown scenario tool', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'unknown_scenario_tool',
+          arguments: {},
+        },
+      }
+
+      await expect(scenarioTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+
+  describe('ActionWordTools handleToolCall', () => {
+    let actionWordTools: ActionWordTools
+
+    beforeEach(() => {
+      actionWordTools = new ActionWordTools(mockApiClient)
+    })
+
+    it('should handle cucumberstudio_list_action_words', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_action_words',
+          arguments: { projectId: '1' },
+        },
+      }
+
+      const result = await actionWordTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+      expect(result.content[0].type).toBe('text')
+    })
+
+    it('should handle cucumberstudio_get_action_word', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_get_action_word',
+          arguments: { projectId: '1', actionWordId: '1' },
+        },
+      }
+
+      const result = await actionWordTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_find_action_words_by_tags', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_find_action_words_by_tags',
+          arguments: { projectId: '1', tags: 'test' },
+        },
+      }
+
+      const result = await actionWordTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should throw for unknown action word tool', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'unknown_action_word_tool',
+          arguments: {},
+        },
+      }
+
+      await expect(actionWordTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+
+  describe('TestRunTools handleToolCall', () => {
+    let testRunTools: TestRunTools
+
+    beforeEach(() => {
+      testRunTools = new TestRunTools(mockApiClient)
+    })
+
+    it('should handle cucumberstudio_list_test_runs', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_test_runs',
+          arguments: { projectId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+      expect(result.content[0].type).toBe('text')
+    })
+
+    it('should handle cucumberstudio_get_test_run', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_get_test_run',
+          arguments: { projectId: '1', testRunId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_get_test_executions', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_get_test_executions',
+          arguments: { projectId: '1', testRunId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_list_builds', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_builds',
+          arguments: { projectId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_get_build', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_get_build',
+          arguments: { projectId: '1', buildId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should handle cucumberstudio_list_execution_environments', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_execution_environments',
+          arguments: { projectId: '1' },
+        },
+      }
+
+      const result = await testRunTools.handleToolCall(request)
+      expect(result.content).toBeDefined()
+    })
+
+    it('should throw for unknown test run tool', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'unknown_test_run_tool',
+          arguments: {},
+        },
+      }
+
+      await expect(testRunTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+})