cucumberstudio-mcp 1.1.0

package/test/tools/projects.test.ts

@@ -0,0 +1,290 @@
+import { CallToolRequest, TextContent } from '@modelcontextprotocol/sdk/types.js'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+
+import { CucumberStudioApiClient } from '../../src/api/client.js'
+import { ProjectTools } from '../../src/tools/projects.js'
+
+// Mock the API client
+vi.mock('../../src/api/client.js')
+
+describe('ProjectTools', () => {
+  let mockApiClient: any
+  let projectTools: ProjectTools
+
+  beforeEach(() => {
+    mockApiClient = {
+      getProjects: vi.fn(),
+      getProject: vi.fn(),
+    }
+
+    projectTools = new ProjectTools(mockApiClient as any)
+  })
+
+  describe('getTools', () => {
+    it('should return array of available tools', () => {
+      const tools = projectTools.getTools()
+
+      expect(tools).toHaveLength(2)
+      expect(tools[0].name).toBe('cucumberstudio_list_projects')
+      expect(tools[1].name).toBe('cucumberstudio_get_project')
+    })
+
+    it('should include proper tool schemas', () => {
+      const tools = projectTools.getTools()
+
+      const listTool = tools.find((t) => t.name === 'cucumberstudio_list_projects')
+      expect(listTool?.description).toContain('List all projects')
+      expect(listTool?.inputSchema.type).toBe('object')
+      expect(listTool?.inputSchema.additionalProperties).toBe(false)
+
+      const getTool = tools.find((t) => t.name === 'cucumberstudio_get_project')
+      expect(getTool?.description).toContain('Get detailed information')
+      expect(getTool?.inputSchema.required).toContain('projectId')
+    })
+  })
+
+  describe('handleToolCall', () => {
+    describe('cucumberstudio_list_projects', () => {
+      it('should handle list projects request without parameters', async () => {
+        const mockResponse = {
+          data: [
+            {
+              id: '1',
+              attributes: {
+                name: 'Test Project',
+                description: 'A test project',
+                created_at: '2023-01-01T00:00:00Z',
+                updated_at: '2023-01-02T00:00:00Z',
+              },
+            },
+          ],
+          meta: { total_count: 1 },
+        }
+
+        mockApiClient.getProjects.mockResolvedValue(mockResponse)
+
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_list_projects',
+            arguments: {},
+          },
+        }
+
+        const result = await projectTools.handleToolCall(request)
+
+        expect(mockApiClient.getProjects).toHaveBeenCalledWith({})
+        expect(result.content).toHaveLength(1)
+
+        const content = result.content[0] as TextContent
+        const responseData = JSON.parse(content.text)
+
+        expect(responseData.projects).toHaveLength(1)
+        expect(responseData.projects[0]).toEqual({
+          id: '1',
+          name: 'Test Project',
+          description: 'A test project',
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-02T00:00:00Z',
+        })
+        expect(responseData.meta).toEqual({ total_count: 1 })
+      })
+
+      it('should handle list projects request with pagination', async () => {
+        const mockResponse = {
+          data: [],
+          meta: { total_count: 0 },
+        }
+
+        mockApiClient.getProjects.mockResolvedValue(mockResponse)
+
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_list_projects',
+            arguments: {
+              pagination: { page: 2, pageSize: 10 },
+              filter: { name: 'test' },
+            },
+          },
+        }
+
+        await projectTools.handleToolCall(request)
+
+        expect(mockApiClient.getProjects).toHaveBeenCalledWith({
+          'page[number]': 2,
+          'page[size]': 10,
+          'filter[name]': 'test',
+        })
+      })
+
+      it('should handle single project data format', async () => {
+        const mockResponse = {
+          data: {
+            id: '1',
+            attributes: {
+              name: 'Single Project',
+              description: 'Single project response',
+              created_at: '2023-01-01T00:00:00Z',
+              updated_at: '2023-01-02T00:00:00Z',
+            },
+          },
+        }
+
+        mockApiClient.getProjects.mockResolvedValue(mockResponse)
+
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_list_projects',
+            arguments: {},
+          },
+        }
+
+        const result = await projectTools.handleToolCall(request)
+        const content = result.content[0] as TextContent
+        const responseData = JSON.parse(content.text)
+
+        expect(responseData.projects).toHaveLength(1)
+        expect(responseData.projects[0].name).toBe('Single Project')
+      })
+    })
+
+    describe('cucumberstudio_get_project', () => {
+      it('should handle get project request', async () => {
+        const mockResponse = {
+          data: {
+            id: '123',
+            type: 'projects',
+            attributes: {
+              name: 'Specific Project',
+              description: 'Project details',
+              created_at: '2023-01-01T00:00:00Z',
+              updated_at: '2023-01-02T00:00:00Z',
+            },
+            relationships: {
+              scenarios: { data: [] },
+            },
+          },
+          included: [],
+        }
+
+        mockApiClient.getProject.mockResolvedValue(mockResponse)
+
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_get_project',
+            arguments: { projectId: '123' },
+          },
+        }
+
+        const result = await projectTools.handleToolCall(request)
+
+        expect(mockApiClient.getProject).toHaveBeenCalledWith('123')
+
+        const content = result.content[0] as TextContent
+        const responseData = JSON.parse(content.text)
+
+        expect(responseData.project).toEqual({
+          id: '123',
+          type: 'projects',
+          name: 'Specific Project',
+          description: 'Project details',
+          created_at: '2023-01-01T00:00:00Z',
+          updated_at: '2023-01-02T00:00:00Z',
+          relationships: { scenarios: { data: [] } },
+        })
+        expect(responseData.included).toEqual([])
+      })
+
+      it('should validate required projectId parameter', async () => {
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_get_project',
+            arguments: {},
+          },
+        }
+
+        await expect(projectTools.handleToolCall(request)).rejects.toThrow()
+      })
+
+      it('should validate empty projectId', async () => {
+        const request: CallToolRequest = {
+          method: 'tools/call',
+          params: {
+            name: 'cucumberstudio_get_project',
+            arguments: { projectId: '' },
+          },
+        }
+
+        await expect(projectTools.handleToolCall(request)).rejects.toThrow()
+      })
+    })
+
+    it('should throw error for unknown tool', async () => {
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'unknown_tool',
+          arguments: {},
+        },
+      }
+
+      await expect(projectTools.handleToolCall(request)).rejects.toThrow('Unknown tool: unknown_tool')
+    })
+
+    it('should handle API errors gracefully', async () => {
+      mockApiClient.getProjects.mockRejectedValue(new Error('API Error'))
+
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_projects',
+          arguments: {},
+        },
+      }
+
+      await expect(projectTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+
+  describe('error handling', () => {
+    it('should handle missing project attributes', async () => {
+      const mockResponse = {
+        data: [
+          {
+            id: '1',
+            type: 'projects',
+            attributes: {
+              // Missing name field to test fallback
+            },
+          },
+        ],
+      }
+
+      mockApiClient.getProjects.mockResolvedValue(mockResponse)
+
+      const request: CallToolRequest = {
+        method: 'tools/call',
+        params: {
+          name: 'cucumberstudio_list_projects',
+          arguments: {},
+        },
+      }
+
+      const result = await projectTools.handleToolCall(request)
+      const content = result.content[0] as TextContent
+      const responseData = JSON.parse(content.text)
+
+      expect(responseData.projects[0]).toEqual({
+        id: '1',
+        name: 'Unknown',
+        description: '',
+        created_at: undefined,
+        updated_at: undefined,
+      })
+    })
+  })
+})

package/test/tools/tools-basic.test.ts

@@ -0,0 +1,146 @@
+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 Basic Functionality', () => {
+  let mockApiClient: any
+
+  beforeEach(() => {
+    mockApiClient = {
+      getProjects: vi.fn(),
+      getProject: vi.fn(),
+      getScenarios: vi.fn(),
+      getScenario: vi.fn(),
+      getFolders: vi.fn(),
+      getActionWords: vi.fn(),
+      getActionWord: vi.fn(),
+      getTestRuns: vi.fn(),
+      getTestRun: vi.fn(),
+      getTestExecutions: vi.fn(),
+      getBuilds: vi.fn(),
+      getBuild: vi.fn(),
+      getExecutionEnvironments: vi.fn(),
+    }
+  })
+
+  describe('ScenarioTools', () => {
+    it('should instantiate and provide tools', () => {
+      const scenarioTools = new ScenarioTools(mockApiClient)
+      const tools = scenarioTools.getTools()
+
+      expect(tools).toBeDefined()
+      expect(Array.isArray(tools)).toBe(true)
+      expect(tools.length).toBeGreaterThan(0)
+
+      // Check that all tools have required properties
+      tools.forEach((tool) => {
+        expect(tool.name).toBeDefined()
+        expect(tool.description).toBeDefined()
+        expect(tool.inputSchema).toBeDefined()
+      })
+    })
+
+    it('should have scenario-related tool names', () => {
+      const scenarioTools = new ScenarioTools(mockApiClient)
+      const tools = scenarioTools.getTools()
+      const toolNames = tools.map((tool) => tool.name)
+
+      expect(toolNames.some((name) => name.includes('scenario'))).toBe(true)
+    })
+
+    it('should throw error for unknown tool', async () => {
+      const scenarioTools = new ScenarioTools(mockApiClient)
+
+      const request = {
+        method: 'tools/call' as const,
+        params: {
+          name: 'unknown_tool',
+          arguments: {},
+        },
+      }
+      await expect(scenarioTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+
+  describe('ActionWordTools', () => {
+    it('should instantiate and provide tools', () => {
+      const actionWordTools = new ActionWordTools(mockApiClient)
+      const tools = actionWordTools.getTools()
+
+      expect(tools).toBeDefined()
+      expect(Array.isArray(tools)).toBe(true)
+      expect(tools.length).toBeGreaterThan(0)
+
+      tools.forEach((tool) => {
+        expect(tool.name).toBeDefined()
+        expect(tool.description).toBeDefined()
+        expect(tool.inputSchema).toBeDefined()
+      })
+    })
+
+    it('should have action word related tool names', () => {
+      const actionWordTools = new ActionWordTools(mockApiClient)
+      const tools = actionWordTools.getTools()
+      const toolNames = tools.map((tool) => tool.name)
+
+      expect(toolNames.some((name) => name.includes('action_word'))).toBe(true)
+    })
+
+    it('should throw error for unknown tool', async () => {
+      const actionWordTools = new ActionWordTools(mockApiClient)
+
+      const request = {
+        method: 'tools/call' as const,
+        params: {
+          name: 'unknown_tool',
+          arguments: {},
+        },
+      }
+      await expect(actionWordTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+
+  describe('TestRunTools', () => {
+    it('should instantiate and provide tools', () => {
+      const testRunTools = new TestRunTools(mockApiClient)
+      const tools = testRunTools.getTools()
+
+      expect(tools).toBeDefined()
+      expect(Array.isArray(tools)).toBe(true)
+      expect(tools.length).toBeGreaterThan(0)
+
+      tools.forEach((tool) => {
+        expect(tool.name).toBeDefined()
+        expect(tool.description).toBeDefined()
+        expect(tool.inputSchema).toBeDefined()
+      })
+    })
+
+    it('should have test run related tool names', () => {
+      const testRunTools = new TestRunTools(mockApiClient)
+      const tools = testRunTools.getTools()
+      const toolNames = tools.map((tool) => tool.name)
+
+      expect(toolNames.some((name) => name.includes('test_run') || name.includes('build'))).toBe(true)
+    })
+
+    it('should throw error for unknown tool', async () => {
+      const testRunTools = new TestRunTools(mockApiClient)
+
+      const request = {
+        method: 'tools/call' as const,
+        params: {
+          name: 'unknown_tool',
+          arguments: {},
+        },
+      }
+      await expect(testRunTools.handleToolCall(request)).rejects.toThrow()
+    })
+  })
+})

package/test/transports/http-basic.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi } from 'vitest'
+
+import { StreamableHttpTransport } from '@/transports/http.js'
+import { NoOpLogger } from '@/utils/logger.js'
+
+describe('StreamableHttpTransport Basic', () => {
+  describe('constructor', () => {
+    it('should create transport with default options', () => {
+      const mockCreateServer = vi.fn()
+      const logger = new NoOpLogger()
+      const transport = new StreamableHttpTransport(
+        mockCreateServer,
+        {
+          port: 3000,
+          host: '127.0.0.1',
+          cors: { origin: true },
+        },
+        logger,
+      )
+
+      expect(transport).toBeDefined()
+      expect(typeof transport.start).toBe('function')
+      expect(typeof transport.close).toBe('function')
+    })
+
+    it('should handle custom CORS options', () => {
+      const mockCreateServer = vi.fn()
+      const logger = new NoOpLogger()
+      const transport = new StreamableHttpTransport(
+        mockCreateServer,
+        {
+          port: 3001,
+          host: 'localhost',
+          cors: {
+            origin: ['http://localhost:3000'],
+            credentials: true,
+          },
+        },
+        logger,
+      )
+
+      expect(transport).toBeDefined()
+    })
+  })
+
+  describe('origin validation', () => {
+    it('should validate localhost origins', () => {
+      const mockCreateServer = vi.fn()
+      const logger = new NoOpLogger()
+      const transport = new StreamableHttpTransport(
+        mockCreateServer,
+        {
+          port: 3000,
+          host: '127.0.0.1',
+          cors: { origin: true },
+        },
+        logger,
+      )
+
+      // Test that the transport can be instantiated with localhost origins
+      expect(transport).toBeDefined()
+    })
+  })
+
+  describe('server management', () => {
+    it('should handle server lifecycle methods', async () => {
+      const mockCreateServer = vi.fn()
+      const logger = new NoOpLogger()
+      const transport = new StreamableHttpTransport(
+        mockCreateServer,
+        {
+          port: 0, // Use random port to avoid conflicts
+          host: '127.0.0.1',
+          cors: { origin: true },
+        },
+        logger,
+      )
+
+      // Test that lifecycle methods exist and can be called
+      expect(typeof transport.start).toBe('function')
+      expect(typeof transport.close).toBe('function')
+
+      // For now, just test that close doesn't throw when called without starting
+      await expect(transport.close()).resolves.not.toThrow()
+    })
+  })
+})

package/test/transports/http-simple.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest'
+
+// Simple HTTP transport test without complex express mocking
+describe('StreamableHttpTransport (Simple)', () => {
+  it('should validate that HTTP transport class can be imported', async () => {
+    const { StreamableHttpTransport } = await import('@/transports/http.js')
+    expect(StreamableHttpTransport).toBeDefined()
+    expect(typeof StreamableHttpTransport).toBe('function')
+  })
+
+  it('should validate HttpTransportOptions interface', () => {
+    // Test that we can create valid options
+    const options = {
+      port: 3000,
+      host: '127.0.0.1',
+      cors: {
+        origin: true,
+        credentials: true,
+      },
+    }
+
+    expect(options.port).toBe(3000)
+    expect(options.host).toBe('127.0.0.1')
+    expect(options.cors.origin).toBe(true)
+  })
+
+  it('should test origin validation helper functions', async () => {
+    // We can test any exported utility functions here
+    // For now, just verify the module loads properly
+    const httpModule = await import('@/transports/http.js')
+    expect(httpModule).toBeDefined()
+  })
+})

package/test/transports/stdio.test.ts

@@ -0,0 +1,73 @@
+// import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+
+import { StdioTransport } from '../../src/transports/stdio.js'
+
+// Mock the SDK components
+vi.mock('@modelcontextprotocol/sdk/server/index.js')
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js')
+
+describe('StdioTransport', () => {
+  let mockServer: any
+  let mockStdioTransport: any
+  let transport: StdioTransport
+
+  beforeEach(() => {
+    mockServer = {
+      connect: vi.fn(),
+    }
+
+    mockStdioTransport = {
+      close: vi.fn(),
+    }
+
+    vi.mocked(StdioServerTransport).mockImplementation(() => mockStdioTransport)
+
+    transport = new StdioTransport(mockServer)
+  })
+
+  describe('constructor', () => {
+    it('should create StdioServerTransport instance', () => {
+      expect(StdioServerTransport).toHaveBeenCalled()
+    })
+
+    it('should store server reference', () => {
+      expect(transport).toBeDefined()
+    })
+  })
+
+  describe('start', () => {
+    it('should connect server to transport', async () => {
+      mockServer.connect.mockResolvedValue(undefined)
+
+      await transport.start()
+
+      expect(mockServer.connect).toHaveBeenCalledWith(mockStdioTransport)
+    })
+
+    it('should handle connection errors', async () => {
+      const error = new Error('Connection failed')
+      mockServer.connect.mockRejectedValue(error)
+
+      await expect(transport.start()).rejects.toThrow('Connection failed')
+    })
+  })
+
+  describe('close', () => {
+    it('should close the transport', async () => {
+      mockStdioTransport.close.mockResolvedValue(undefined)
+
+      await transport.close()
+
+      expect(mockStdioTransport.close).toHaveBeenCalled()
+    })
+
+    it('should handle close errors gracefully', async () => {
+      const error = new Error('Close failed')
+      mockStdioTransport.close.mockRejectedValue(error)
+
+      await expect(transport.close()).rejects.toThrow('Close failed')
+    })
+  })
+})