cucumberstudio-mcp 1.1.0

package/test/utils/errors.test.ts

@@ -0,0 +1,117 @@
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { describe, it, expect } from 'vitest'
+
+import { createMcpError, safeExecute } from '@/utils/errors.js'
+
+describe('errors utilities', () => {
+  describe('createMcpError', () => {
+    it('should return McpError as-is', () => {
+      const originalError = new McpError(ErrorCode.InvalidParams, 'Test error')
+      const result = createMcpError(originalError)
+
+      expect(result).toBe(originalError)
+    })
+
+    it('should convert CucumberStudioApiError to McpError', () => {
+      const apiError = new Error('API failed')
+      apiError.name = 'CucumberStudioApiError'
+
+      const result = createMcpError(apiError, 'test context')
+
+      expect(result).toBeInstanceOf(McpError)
+      expect(result.code).toBe(ErrorCode.InternalError)
+      expect(result.message).toContain('Cucumber Studio API error (test context): API failed')
+    })
+
+    it('should convert ZodError to McpError', () => {
+      const zodError = new Error('Validation failed')
+      zodError.name = 'ZodError'
+
+      const result = createMcpError(zodError)
+
+      expect(result).toBeInstanceOf(McpError)
+      expect(result.code).toBe(ErrorCode.InvalidParams)
+      expect(result.message).toContain('Validation error: Validation failed')
+    })
+
+    it('should convert generic Error to McpError', () => {
+      const genericError = new Error('Something went wrong')
+
+      const result = createMcpError(genericError, 'operation')
+
+      expect(result).toBeInstanceOf(McpError)
+      expect(result.code).toBe(ErrorCode.InternalError)
+      expect(result.message).toContain('operation: Something went wrong')
+    })
+
+    it('should handle unknown error types', () => {
+      const unknownError = 'string error'
+
+      const result = createMcpError(unknownError)
+
+      expect(result).toBeInstanceOf(McpError)
+      expect(result.code).toBe(ErrorCode.InternalError)
+      expect(result.message).toContain('Unknown error: string error')
+    })
+
+    it('should handle context parameter', () => {
+      const error = new Error('Test error')
+
+      const result = createMcpError(error, 'test context')
+
+      expect(result.message).toContain('test context: Test error')
+    })
+  })
+
+  describe('safeExecute', () => {
+    it('should return result on successful execution', async () => {
+      const operation = async () => 'success'
+
+      const result = await safeExecute(operation)
+
+      expect(result).toBe('success')
+    })
+
+    it('should throw McpError on operation failure', async () => {
+      const operation = async () => {
+        throw new Error('Operation failed')
+      }
+
+      await expect(safeExecute(operation, 'test operation')).rejects.toThrow(McpError)
+    })
+
+    it('should preserve context in error', async () => {
+      const operation = async () => {
+        throw new Error('Operation failed')
+      }
+
+      try {
+        await safeExecute(operation, 'test operation')
+      } catch (error) {
+        expect(error).toBeInstanceOf(McpError)
+        expect((error as McpError).message).toContain('test operation: Operation failed')
+      }
+    })
+
+    it('should handle async operations that return promises', async () => {
+      const operation = () => Promise.resolve(42)
+
+      const result = await safeExecute(operation)
+
+      expect(result).toBe(42)
+    })
+
+    it('should handle operations that throw McpError directly', async () => {
+      const originalError = new McpError(ErrorCode.InvalidParams, 'Invalid input')
+      const operation = async () => {
+        throw originalError
+      }
+
+      try {
+        await safeExecute(operation)
+      } catch (error) {
+        expect(error).toBe(originalError)
+      }
+    })
+  })
+})

package/test/utils/validation.test.ts

@@ -0,0 +1,261 @@
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+import {
+  ProjectIdSchema,
+  ScenarioIdSchema,
+  ActionWordIdSchema,
+  FolderIdSchema,
+  TestRunIdSchema,
+  BuildIdSchema,
+  PaginationSchema,
+  FilterSchema,
+  ListParamsSchema,
+  convertToApiParams,
+  validateInput,
+  validateEnvironment,
+} from '../../src/utils/validation.js'
+
+describe('validation utilities', () => {
+  describe('schemas', () => {
+    it('should validate project ID', () => {
+      expect(ProjectIdSchema.parse('project-123')).toBe('project-123')
+      expect(() => ProjectIdSchema.parse('')).toThrow()
+      expect(() => ProjectIdSchema.parse(null)).toThrow()
+    })
+
+    it('should validate scenario ID', () => {
+      expect(ScenarioIdSchema.parse('scenario-456')).toBe('scenario-456')
+      expect(() => ScenarioIdSchema.parse('')).toThrow()
+    })
+
+    it('should validate action word ID', () => {
+      expect(ActionWordIdSchema.parse('action-789')).toBe('action-789')
+      expect(() => ActionWordIdSchema.parse('')).toThrow()
+    })
+
+    it('should validate folder ID', () => {
+      expect(FolderIdSchema.parse('folder-101')).toBe('folder-101')
+      expect(() => FolderIdSchema.parse('')).toThrow()
+    })
+
+    it('should validate test run ID', () => {
+      expect(TestRunIdSchema.parse('testrun-202')).toBe('testrun-202')
+      expect(() => TestRunIdSchema.parse('')).toThrow()
+    })
+
+    it('should validate build ID', () => {
+      expect(BuildIdSchema.parse('build-303')).toBe('build-303')
+      expect(() => BuildIdSchema.parse('')).toThrow()
+    })
+
+    it('should validate pagination schema', () => {
+      expect(PaginationSchema.parse({ page: 1, pageSize: 10 })).toEqual({ page: 1, pageSize: 10 })
+      expect(PaginationSchema.parse({})).toEqual({})
+      expect(PaginationSchema.parse(undefined)).toBeUndefined()
+      expect(() => PaginationSchema.parse({ page: 0 })).toThrow()
+      expect(() => PaginationSchema.parse({ pageSize: 101 })).toThrow()
+    })
+
+    it('should validate filter schema', () => {
+      expect(FilterSchema.parse({ name: 'test', tags: 'tag1,tag2' })).toEqual({ name: 'test', tags: 'tag1,tag2' })
+      expect(FilterSchema.parse({})).toEqual({})
+      expect(FilterSchema.parse(undefined)).toBeUndefined()
+    })
+
+    it('should validate list params schema', () => {
+      const validParams = {
+        pagination: { page: 1, pageSize: 20 },
+        filter: { name: 'test' },
+      }
+      expect(ListParamsSchema.parse(validParams)).toEqual(validParams)
+      expect(ListParamsSchema.parse({})).toEqual({})
+      expect(ListParamsSchema.parse(undefined)).toBeUndefined()
+    })
+  })
+
+  describe('convertToApiParams', () => {
+    it('should convert pagination parameters', () => {
+      const params = {
+        pagination: { page: 2, pageSize: 25 },
+      }
+
+      const result = convertToApiParams(params)
+
+      expect(result).toEqual({
+        'page[number]': 2,
+        'page[size]': 25,
+      })
+    })
+
+    it('should convert filter parameters', () => {
+      const params = {
+        filter: { name: 'test-scenario', tags: 'smoke,regression' },
+      }
+
+      const result = convertToApiParams(params)
+
+      expect(result).toEqual({
+        'filter[name]': 'test-scenario',
+        'filter[tags]': 'smoke,regression',
+      })
+    })
+
+    it('should convert combined parameters', () => {
+      const params = {
+        pagination: { page: 3, pageSize: 50 },
+        filter: { name: 'api-test', tags: 'api' },
+      }
+
+      const result = convertToApiParams(params)
+
+      expect(result).toEqual({
+        'page[number]': 3,
+        'page[size]': 50,
+        'filter[name]': 'api-test',
+        'filter[tags]': 'api',
+      })
+    })
+
+    it('should handle undefined parameters', () => {
+      const result = convertToApiParams()
+      expect(result).toEqual({})
+    })
+
+    it('should handle empty parameters', () => {
+      const result = convertToApiParams({})
+      expect(result).toEqual({})
+    })
+
+    it('should handle partial parameters', () => {
+      const params = {
+        pagination: { page: 1 },
+        filter: { tags: 'integration' },
+      }
+
+      const result = convertToApiParams(params)
+
+      expect(result).toEqual({
+        'page[number]': 1,
+        'filter[tags]': 'integration',
+      })
+    })
+  })
+
+  describe('validateInput', () => {
+    it('should return parsed input for valid data', () => {
+      const result = validateInput(ProjectIdSchema, 'valid-project-id')
+      expect(result).toBe('valid-project-id')
+    })
+
+    it('should throw McpError for invalid data', () => {
+      expect(() => validateInput(ProjectIdSchema, '')).toThrow(McpError)
+      expect(() => validateInput(ProjectIdSchema, null)).toThrow(McpError)
+    })
+
+    it('should include context in error message', () => {
+      try {
+        validateInput(ProjectIdSchema, '', 'test operation')
+      } catch (error) {
+        expect(error).toBeInstanceOf(McpError)
+        expect((error as McpError).code).toBe(ErrorCode.InvalidParams)
+        expect((error as McpError).message).toContain('test operation')
+      }
+    })
+
+    it('should handle complex schema validation', () => {
+      const complexInput = {
+        pagination: { page: 1, pageSize: 10 },
+        filter: { name: 'test' },
+      }
+
+      const result = validateInput(ListParamsSchema, complexInput)
+      expect(result).toEqual(complexInput)
+    })
+
+    it('should provide detailed error messages for schema violations', () => {
+      try {
+        validateInput(PaginationSchema, { page: 0, pageSize: 101 })
+      } catch (error) {
+        expect(error).toBeInstanceOf(McpError)
+        const mcpError = error as McpError
+        expect(mcpError.message).toContain('page')
+        expect(mcpError.message).toContain('pageSize')
+      }
+    })
+  })
+
+  describe('validateEnvironment', () => {
+    let originalEnv: NodeJS.ProcessEnv
+
+    beforeEach(() => {
+      originalEnv = { ...process.env }
+    })
+
+    afterEach(() => {
+      process.env = originalEnv
+    })
+
+    it('should pass when all required environment variables are present', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      expect(() => validateEnvironment()).not.toThrow()
+    })
+
+    it('should throw McpError when access token is missing', () => {
+      delete process.env.CUCUMBERSTUDIO_ACCESS_TOKEN
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      expect(() => validateEnvironment()).toThrow(McpError)
+      expect(() => validateEnvironment()).toThrow(/CUCUMBERSTUDIO_ACCESS_TOKEN/)
+    })
+
+    it('should throw McpError when client ID is missing', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      delete process.env.CUCUMBERSTUDIO_CLIENT_ID
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      expect(() => validateEnvironment()).toThrow(McpError)
+      expect(() => validateEnvironment()).toThrow(/CUCUMBERSTUDIO_CLIENT_ID/)
+    })
+
+    it('should throw McpError when UID is missing', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client'
+      delete process.env.CUCUMBERSTUDIO_UID
+
+      expect(() => validateEnvironment()).toThrow(McpError)
+      expect(() => validateEnvironment()).toThrow(/CUCUMBERSTUDIO_UID/)
+    })
+
+    it('should throw McpError when multiple variables are missing', () => {
+      delete process.env.CUCUMBERSTUDIO_ACCESS_TOKEN
+      delete process.env.CUCUMBERSTUDIO_CLIENT_ID
+      delete process.env.CUCUMBERSTUDIO_UID
+
+      try {
+        validateEnvironment()
+      } catch (error) {
+        expect(error).toBeInstanceOf(McpError)
+        const mcpError = error as McpError
+        expect(mcpError.message).toContain('CUCUMBERSTUDIO_ACCESS_TOKEN')
+        expect(mcpError.message).toContain('CUCUMBERSTUDIO_CLIENT_ID')
+        expect(mcpError.message).toContain('CUCUMBERSTUDIO_UID')
+      }
+    })
+
+    it('should have correct error code', () => {
+      delete process.env.CUCUMBERSTUDIO_ACCESS_TOKEN
+
+      try {
+        validateEnvironment()
+      } catch (error) {
+        expect(error).toBeInstanceOf(McpError)
+        expect((error as McpError).code).toBe(ErrorCode.InvalidRequest)
+      }
+    })
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build", "dist", "test/**/*"]
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "./build",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@test/*": ["test/*"]
+    }
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules", "build", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,43 @@
+import { defineConfig } from 'vitest/config'
+import tsconfigPaths from 'vite-tsconfig-paths'
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    environment: 'node',
+    globals: true,
+    restoreMocks: true,
+    clearMocks: true,
+    setupFiles: ['./test/setup/vitest.setup.ts'],
+    include: ['test/**/*.test.ts'],
+    exclude: ['node_modules', 'build', 'dist'],
+    reporters: ['default'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/**/*.test.ts',
+        'src/**/*.spec.ts',
+        'src/**/index.ts',
+        'node_modules/',
+        'build/',
+        'dist/',
+        'test/',
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        '**/*.d.ts',
+        'vitest.config.ts',
+        'eslint.config.js',
+        '.prettierrc'
+      ],
+      thresholds: {
+        global: {
+          branches: 85,
+          functions: 85,
+          lines: 85,
+          statements: 85
+        }
+      }
+    }
+  }
+})