cucumberstudio-mcp 1.1.0

package/test/api/types.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest'
+
+describe('API Types', () => {
+  it('should be able to import types module', async () => {
+    const types = await import('@/api/types.js')
+    expect(types).toBeDefined()
+  })
+
+  it('should define type interfaces correctly', () => {
+    // Test that we can create objects matching the expected types
+    const mockApiResponse = {
+      data: [],
+      meta: {
+        total: 0,
+        page: 1,
+        pageSize: 10,
+      },
+    }
+
+    const mockProject = {
+      id: 1,
+      name: 'Test Project',
+      description: 'A test project',
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    }
+
+    const mockScenario = {
+      id: 1,
+      name: 'Test Scenario',
+      description: 'A test scenario',
+      project_id: 1,
+      folder_id: null,
+      tags: ['test'],
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    }
+
+    const mockActionWord = {
+      id: 1,
+      name: 'Test Action Word',
+      description: 'A test action word',
+      project_id: 1,
+      tags: ['test'],
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    }
+
+    const mockTestRun = {
+      id: 1,
+      name: 'Test Run',
+      project_id: 1,
+      status: 'passed',
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    }
+
+    const mockBuild = {
+      id: 1,
+      name: 'Test Build',
+      project_id: 1,
+      status: 'success',
+      created_at: '2024-01-01T00:00:00Z',
+      updated_at: '2024-01-01T00:00:00Z',
+    }
+
+    const mockError = {
+      message: 'Test error',
+      code: 'TEST_ERROR',
+    }
+
+    const mockListParams = {
+      page: 1,
+      pageSize: 10,
+      tags: ['test'],
+    }
+
+    // Verify objects can be created (TypeScript compilation test)
+    expect(mockApiResponse).toBeDefined()
+    expect(mockProject).toBeDefined()
+    expect(mockScenario).toBeDefined()
+    expect(mockActionWord).toBeDefined()
+    expect(mockTestRun).toBeDefined()
+    expect(mockBuild).toBeDefined()
+    expect(mockError).toBeDefined()
+    expect(mockListParams).toBeDefined()
+  })
+})

package/test/config/settings.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+
+import { ConfigManager, configManager } from '../../src/config/settings.js'
+import { SERVER_VERSION } from '../../src/constants.js'
+
+// Mock dotenv to prevent loading actual .env file
+vi.mock('dotenv', () => ({
+  config: vi.fn(() => ({ parsed: {} })),
+}))
+
+describe('ConfigManager', () => {
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(() => {
+    originalEnv = { ...process.env }
+    // Clear ALL cucumber studio and MCP environment variables
+    Object.keys(process.env).forEach((key) => {
+      if (key.startsWith('CUCUMBERSTUDIO_') || key.startsWith('MCP_') || key.startsWith('LOG_')) {
+        delete process.env[key]
+      }
+    })
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  describe('loadFromEnvironment', () => {
+    it('should load valid configuration from environment variables', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      const manager = new ConfigManager()
+      const config = manager.loadFromEnvironment()
+
+      expect(config).toEqual({
+        cucumberStudio: {
+          baseUrl: 'https://studio.cucumberstudio.com/api',
+          accessToken: 'test-token',
+          clientId: 'test-client-id',
+          uid: 'test-uid',
+        },
+        server: {
+          name: 'cucumberstudio-mcp',
+          version: SERVER_VERSION,
+          transport: 'stdio', // Default value
+          port: 3000,
+          host: '0.0.0.0',
+        },
+        logging: {
+          level: 'info', // Default value
+          logApiResponses: false, // Default value
+          logRequestBodies: false,
+          logResponseBodies: false, // Default value
+          transport: 'stderr',
+          filePath: undefined,
+        },
+      })
+    })
+
+    it('should use custom base URL when provided', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+      process.env.CUCUMBERSTUDIO_BASE_URL = 'https://custom-api.example.com'
+
+      const manager = new ConfigManager()
+      const config = manager.loadFromEnvironment()
+
+      expect(config.cucumberStudio.baseUrl).toBe('https://custom-api.example.com')
+    })
+
+    it('should use custom server configuration when provided', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+      process.env.MCP_SERVER_NAME = 'custom-server'
+      process.env.MCP_SERVER_VERSION = '2.0.0'
+      process.env.MCP_TRANSPORT = 'http'
+      process.env.MCP_PORT = '8080'
+      process.env.MCP_HOST = '0.0.0.0'
+
+      const manager = new ConfigManager()
+      const config = manager.loadFromEnvironment()
+
+      expect(config.server).toEqual({
+        name: 'custom-server',
+        version: '2.0.0',
+        transport: 'http',
+        port: 8080,
+        host: '0.0.0.0',
+      })
+    })
+
+    it('should throw error when access token is missing', () => {
+      // Only set other required fields, leave access token missing
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow(
+        /Configuration validation failed.*CUCUMBERSTUDIO_ACCESS_TOKEN/,
+      )
+    })
+
+    it('should throw error when client ID is missing', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow(/Configuration validation failed.*CUCUMBERSTUDIO_CLIENT_ID/)
+    })
+
+    it('should throw error when UID is missing', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow(/Configuration validation failed.*CUCUMBERSTUDIO_UID/)
+    })
+
+    it('should throw error when base URL is invalid', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+      process.env.CUCUMBERSTUDIO_BASE_URL = 'invalid-url'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow()
+    })
+
+    it('should throw error when transport is invalid', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+      process.env.MCP_TRANSPORT = 'invalid-transport'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow()
+    })
+
+    it('should throw error when port is invalid', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+      process.env.MCP_PORT = 'invalid-port'
+
+      const manager = new ConfigManager()
+
+      expect(() => manager.loadFromEnvironment()).toThrow()
+    })
+  })
+
+  describe('getConfig', () => {
+    it('should return config after loading', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      const manager = new ConfigManager()
+      const config1 = manager.loadFromEnvironment()
+      const config2 = manager.getConfig()
+
+      expect(config2).toEqual(config1)
+    })
+
+    it('should throw error when config not loaded', () => {
+      const manager = new ConfigManager()
+
+      expect(() => manager.getConfig()).toThrow('Configuration not loaded. Call loadFromEnvironment() first.')
+    })
+  })
+
+  describe('validate', () => {
+    it('should return true when config is valid', () => {
+      process.env.CUCUMBERSTUDIO_ACCESS_TOKEN = 'test-token'
+      process.env.CUCUMBERSTUDIO_CLIENT_ID = 'test-client-id'
+      process.env.CUCUMBERSTUDIO_UID = 'test-uid'
+
+      const manager = new ConfigManager()
+      manager.loadFromEnvironment()
+
+      expect(manager.validate()).toBe(true)
+    })
+
+    it('should return false when config not loaded', () => {
+      const manager = new ConfigManager()
+
+      expect(manager.validate()).toBe(false)
+    })
+  })
+
+  describe('singleton instance', () => {
+    it('should export a singleton instance', () => {
+      expect(configManager).toBeInstanceOf(ConfigManager)
+    })
+  })
+})

package/test/mocks/data/action-words.ts

@@ -0,0 +1,40 @@
+export const mockActionWords = [
+  {
+    id: 1,
+    name: 'Login with username and password',
+    description: 'Authenticate user with provided credentials',
+    project_id: 1,
+    tags: ['authentication', 'login'],
+    parameters: [
+      { name: 'username', type: 'string' },
+      { name: 'password', type: 'string' },
+    ],
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-15T10:30:00Z',
+  },
+  {
+    id: 2,
+    name: 'Search for product',
+    description: 'Search for a product in the catalog',
+    project_id: 1,
+    tags: ['search', 'catalog'],
+    parameters: [{ name: 'product_name', type: 'string' }],
+    created_at: '2024-01-02T00:00:00Z',
+    updated_at: '2024-01-16T11:30:00Z',
+  },
+  {
+    id: 3,
+    name: 'Add product to cart',
+    description: 'Add a product to shopping cart',
+    project_id: 1,
+    tags: ['cart', 'shopping'],
+    parameters: [
+      { name: 'product_id', type: 'number' },
+      { name: 'quantity', type: 'number' },
+    ],
+    created_at: '2024-01-03T00:00:00Z',
+    updated_at: '2024-01-17T12:30:00Z',
+  },
+]
+
+export const mockActionWord = mockActionWords[0]

package/test/mocks/data/index.ts

@@ -0,0 +1,13 @@
+// Export all mock data for easy importing
+export * from './projects.js'
+export * from './scenarios.js'
+export * from './action-words.js'
+export * from './test-runs.js'
+
+// Consolidated export for convenience
+export const mockData = {
+  projects: () => import('./projects.js'),
+  scenarios: () => import('./scenarios.js'),
+  actionWords: () => import('./action-words.js'),
+  testRuns: () => import('./test-runs.js'),
+}

package/test/mocks/data/projects.ts

@@ -0,0 +1,38 @@
+export const mockProjects = {
+  data: [
+    {
+      id: '1',
+      type: 'projects',
+      attributes: {
+        name: 'E-commerce Platform',
+        description: 'Main e-commerce testing project',
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-15T10:30:00Z',
+      },
+    },
+    {
+      id: '2',
+      type: 'projects',
+      attributes: {
+        name: 'Mobile App Backend',
+        description: 'API testing for mobile application',
+        created_at: '2024-01-05T00:00:00Z',
+        updated_at: '2024-01-20T14:45:00Z',
+      },
+    },
+    {
+      id: '3',
+      type: 'projects',
+      attributes: {
+        name: 'Authentication Service',
+        description: 'User authentication and authorization testing',
+        created_at: '2024-01-10T00:00:00Z',
+        updated_at: '2024-01-25T09:15:00Z',
+      },
+    },
+  ],
+}
+
+export const mockProject = {
+  data: mockProjects.data[0],
+}

package/test/mocks/data/scenarios.ts

@@ -0,0 +1,53 @@
+export const mockScenarios = [
+  {
+    id: 1,
+    name: 'User Login',
+    description: 'Test successful user login flow',
+    project_id: 1,
+    folder_id: null,
+    tags: ['authentication', 'login', 'critical'],
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-15T10:30:00Z',
+  },
+  {
+    id: 2,
+    name: 'Product Search',
+    description: 'Search for products in catalog',
+    project_id: 1,
+    folder_id: 10,
+    tags: ['search', 'catalog', 'core'],
+    created_at: '2024-01-02T00:00:00Z',
+    updated_at: '2024-01-16T11:30:00Z',
+  },
+  {
+    id: 3,
+    name: 'Checkout Process',
+    description: 'Complete purchase flow',
+    project_id: 1,
+    folder_id: 11,
+    tags: ['checkout', 'payment', 'critical'],
+    created_at: '2024-01-03T00:00:00Z',
+    updated_at: '2024-01-17T12:30:00Z',
+  },
+]
+
+export const mockFolders = [
+  {
+    id: 10,
+    name: 'Core Features',
+    project_id: 1,
+    parent_id: null,
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  },
+  {
+    id: 11,
+    name: 'Payment Flow',
+    project_id: 1,
+    parent_id: 10,
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  },
+]
+
+export const mockScenario = mockScenarios[0]

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

@@ -0,0 +1,101 @@
+export const mockTestRuns = [
+  {
+    id: 1,
+    name: 'Regression Test Suite',
+    project_id: 1,
+    execution_environment_id: 1,
+    status: 'passed',
+    statuses: {
+      passed: 45,
+      failed: 2,
+      skipped: 3,
+      undefined: 0,
+      blocked: 0,
+    },
+    created_at: '2024-01-15T09:00:00Z',
+    updated_at: '2024-01-15T11:30:00Z',
+  },
+  {
+    id: 2,
+    name: 'Smoke Test',
+    project_id: 1,
+    execution_environment_id: 2,
+    status: 'failed',
+    statuses: {
+      passed: 20,
+      failed: 5,
+      skipped: 0,
+      undefined: 0,
+      blocked: 1,
+    },
+    created_at: '2024-01-16T14:00:00Z',
+    updated_at: '2024-01-16T15:45:00Z',
+  },
+]
+
+export const mockTestExecutions = [
+  {
+    id: 1,
+    test_run_id: 1,
+    scenario_id: 1,
+    status: 'passed',
+    description: 'User login test execution',
+    created_at: '2024-01-15T09:15:00Z',
+    updated_at: '2024-01-15T09:45:00Z',
+  },
+  {
+    id: 2,
+    test_run_id: 1,
+    scenario_id: 2,
+    status: 'failed',
+    description: 'Product search test execution',
+    error_message: 'Search API timeout',
+    created_at: '2024-01-15T09:45:00Z',
+    updated_at: '2024-01-15T10:15:00Z',
+  },
+]
+
+export const mockBuilds = [
+  {
+    id: 1,
+    name: 'Release v2.1.0',
+    project_id: 1,
+    status: 'success',
+    test_runs_count: 5,
+    scenarios_count: 150,
+    created_at: '2024-01-15T00:00:00Z',
+    updated_at: '2024-01-15T12:00:00Z',
+  },
+  {
+    id: 2,
+    name: 'Hotfix v2.0.1',
+    project_id: 1,
+    status: 'failed',
+    test_runs_count: 2,
+    scenarios_count: 50,
+    created_at: '2024-01-14T00:00:00Z',
+    updated_at: '2024-01-14T08:30:00Z',
+  },
+]
+
+export const mockExecutionEnvironments = [
+  {
+    id: 1,
+    name: 'Production',
+    project_id: 1,
+    description: 'Production environment testing',
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  },
+  {
+    id: 2,
+    name: 'Staging',
+    project_id: 1,
+    description: 'Staging environment for pre-production testing',
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z',
+  },
+]
+
+export const mockTestRun = mockTestRuns[0]
+export const mockBuild = mockBuilds[0]

package/test/mocks/handlers/action-words.ts

@@ -0,0 +1,52 @@
+import { http, HttpResponse } from 'msw'
+
+import { mockActionWords, mockActionWord } from '../data/action-words.js'
+
+const BASE_URL = 'https://api.example.com'
+
+export const actionWordHandlers = [
+  // List action words in a project
+  http.get(`${BASE_URL}/projects/:projectId/actionwords`, ({ 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 projectActionWords = mockActionWords.filter((a) => a.project_id === projectId)
+
+    // Handle query parameters for filtering
+    const url = new URL(request.url)
+    const tags = url.searchParams.get('tags')
+
+    let filteredActionWords = projectActionWords
+
+    if (tags) {
+      const tagList = tags.split(',')
+      filteredActionWords = filteredActionWords.filter((actionWord) =>
+        tagList.some((tag) => actionWord.tags.includes(tag.trim())),
+      )
+    }
+
+    return HttpResponse.json(filteredActionWords)
+  }),
+
+  // Get specific action word
+  http.get(`${BASE_URL}/projects/:projectId/actionwords/:id`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const actionWordId = Number(params.id)
+    const actionWord = mockActionWords.find((a) => a.id === actionWordId)
+
+    if (!actionWord) {
+      return HttpResponse.json({ error: 'Action word not found' }, { status: 404 })
+    }
+
+    return HttpResponse.json(actionWord)
+  }),
+]

package/test/mocks/handlers/index.ts

@@ -0,0 +1,10 @@
+import { actionWordHandlers } from './action-words.js'
+import { projectHandlers } from './projects.js'
+import { scenarioHandlers } from './scenarios.js'
+import { testRunHandlers } from './test-runs.js'
+
+// Combine all handlers
+export const handlers = [...projectHandlers, ...scenarioHandlers, ...actionWordHandlers, ...testRunHandlers]
+
+// Export individual handler groups for selective testing
+export { projectHandlers, scenarioHandlers, actionWordHandlers, testRunHandlers }

package/test/mocks/handlers/projects.ts

@@ -0,0 +1,45 @@
+import { http, HttpResponse } from 'msw'
+
+import { mockProjects, mockProject } from '../data/projects.js'
+
+const BASE_URL = 'https://api.example.com'
+
+export const projectHandlers = [
+  // List all projects
+  http.get(`${BASE_URL}/projects`, ({ request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    return HttpResponse.json(mockProjects)
+  }),
+
+  // Get specific project
+  http.get(`${BASE_URL}/projects/:id`, ({ params, request }) => {
+    const accessToken = request.headers.get('access-token')
+
+    if (!accessToken || accessToken !== 'token') {
+      return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const projectId = String(params.id)
+    const project = mockProjects.data.find((p: any) => p.id === projectId)
+
+    if (!project) {
+      return HttpResponse.json({ error: 'Project not found' }, { status: 404 })
+    }
+
+    return HttpResponse.json({ data: project })
+  }),
+
+  // Error scenarios for testing
+  http.get(`${BASE_URL}/projects/999`, () => {
+    return HttpResponse.json({ error: 'Project not found' }, { status: 404 })
+  }),
+
+  http.get(`${BASE_URL}/projects/error`, () => {
+    return HttpResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }),
+]