@daghis/teamcity-mcp 0.9.0 → 0.9.2

package/tests/unit/teamcity/branch-specification-parser.test.ts

@@ -1,443 +0,0 @@
-/**
- * Tests for BranchSpecificationParser
- */
-import {
-  BranchMatcher,
-  BranchSpec,
-  BranchSpecificationParser,
-} from '@/teamcity/branch-specification-parser';
-
-describe('BranchSpecificationParser', () => {
-  let parser: BranchSpecificationParser;
-
-  beforeEach(() => {
-    parser = new BranchSpecificationParser();
-  });
-
-  describe('parseSpecification', () => {
-    describe('inclusion rules', () => {
-      it('should parse simple inclusion rule', () => {
-        const spec = parser.parseSpecification('+:refs/heads/main');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/main',
-          type: 'include',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-      });
-
-      it('should parse wildcard inclusion rule', () => {
-        const spec = parser.parseSpecification('+:refs/heads/*');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/*',
-          type: 'include',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-
-        // Test the regex matches correctly
-        expect(spec.regex?.test('refs/heads/main')).toBe(true);
-        expect(spec.regex?.test('refs/heads/feature')).toBe(true);
-        expect(spec.regex?.test('refs/heads/feature/test')).toBe(false); // Single wildcard doesn't match nested paths
-        expect(spec.regex?.test('refs/tags/v1.0')).toBe(false);
-      });
-
-      it('should parse multi-level wildcard', () => {
-        const spec = parser.parseSpecification('+:refs/heads/**');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/**',
-          type: 'include',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-
-        // Test double wildcard matches nested paths
-        expect(spec.regex?.test('refs/heads/main')).toBe(true);
-        expect(spec.regex?.test('refs/heads/feature/deep/nested')).toBe(true);
-      });
-
-      it('should handle implicit inclusion (no prefix)', () => {
-        const spec = parser.parseSpecification('refs/heads/main');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/main',
-          type: 'include',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-      });
-    });
-
-    describe('exclusion rules', () => {
-      it('should parse simple exclusion rule', () => {
-        const spec = parser.parseSpecification('-:refs/heads/legacy');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/legacy',
-          type: 'exclude',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-      });
-
-      it('should parse wildcard exclusion rule', () => {
-        const spec = parser.parseSpecification('-:refs/heads/experimental/*');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/experimental/*',
-          type: 'exclude',
-          isDefault: false,
-          regex: expect.any(RegExp),
-        });
-
-        expect(spec.regex?.test('refs/heads/experimental/feature1')).toBe(true);
-        expect(spec.regex?.test('refs/heads/main')).toBe(false);
-      });
-    });
-
-    describe('default branch handling', () => {
-      it('should detect default branch marker', () => {
-        const spec = parser.parseSpecification('+:refs/heads/main (default)');
-
-        expect(spec).toEqual({
-          pattern: 'refs/heads/main',
-          type: 'include',
-          isDefault: true,
-          regex: expect.any(RegExp),
-        });
-      });
-
-      it('should detect <default> placeholder', () => {
-        const spec = parser.parseSpecification('<default>');
-
-        expect(spec).toEqual({
-          pattern: '<default>',
-          type: 'include',
-          isDefault: true,
-          regex: expect.any(RegExp),
-        });
-      });
-    });
-
-    describe('special patterns', () => {
-      it('should handle pull request patterns', () => {
-        const spec = parser.parseSpecification('+:pull/*/head');
-
-        expect(spec.regex?.test('pull/123/head')).toBe(true);
-        expect(spec.regex?.test('pull/456/head')).toBe(true);
-        expect(spec.regex?.test('pull/123/merge')).toBe(false);
-      });
-
-      it('should handle merge request patterns', () => {
-        const spec = parser.parseSpecification('+:merge-requests/*/head');
-
-        expect(spec.regex?.test('merge-requests/789/head')).toBe(true);
-        expect(spec.regex?.test('merge-requests/123/merge')).toBe(false);
-      });
-
-      it('should handle regex groups in patterns', () => {
-        const spec = parser.parseSpecification('+:refs/heads/(feature|bugfix)/*');
-
-        expect(spec.regex?.test('refs/heads/feature/new-login')).toBe(true);
-        expect(spec.regex?.test('refs/heads/bugfix/fix-crash')).toBe(true);
-        expect(spec.regex?.test('refs/heads/hotfix/urgent')).toBe(false);
-      });
-    });
-
-    describe('edge cases', () => {
-      it('should handle empty specification', () => {
-        expect(() => parser.parseSpecification('')).toThrow('Empty branch specification');
-      });
-
-      it('should handle whitespace', () => {
-        const spec = parser.parseSpecification('  +:refs/heads/main  ');
-
-        expect(spec.pattern).toBe('refs/heads/main');
-      });
-
-      it('should handle special characters in branch names', () => {
-        const spec = parser.parseSpecification('+:refs/heads/feature-#123');
-
-        expect(spec.regex?.test('refs/heads/feature-#123')).toBe(true);
-        expect(spec.regex?.test('refs/heads/feature-#456')).toBe(false);
-      });
-    });
-  });
-
-  describe('parseMultipleSpecifications', () => {
-    it('should parse multiple specifications', () => {
-      const specs = parser.parseMultipleSpecifications([
-        '+:refs/heads/*',
-        '-:refs/heads/experimental/*',
-        '+:refs/tags/*',
-      ]);
-
-      expect(specs).toHaveLength(3);
-      expect(specs[0]?.type).toBe('include');
-      expect(specs[1]?.type).toBe('exclude');
-      expect(specs[2]?.type).toBe('include');
-    });
-
-    it('should handle single specification string with newlines', () => {
-      const specs = parser.parseMultipleSpecifications(
-        '+:refs/heads/*\n-:refs/heads/legacy/*\n+:refs/tags/*'
-      );
-
-      expect(specs).toHaveLength(3);
-    });
-
-    it('should skip empty lines', () => {
-      const specs = parser.parseMultipleSpecifications([
-        '+:refs/heads/*',
-        '',
-        '  ',
-        '-:refs/heads/legacy/*',
-      ]);
-
-      expect(specs).toHaveLength(2);
-    });
-
-    it('should preserve order', () => {
-      const specs = parser.parseMultipleSpecifications([
-        '+:refs/heads/main',
-        '-:refs/heads/experimental/*',
-        '+:refs/heads/feature/*',
-        '-:refs/heads/feature/old-*',
-      ]);
-
-      expect(specs[0]?.pattern).toBe('refs/heads/main');
-      expect(specs[1]?.pattern).toBe('refs/heads/experimental/*');
-      expect(specs[2]?.pattern).toBe('refs/heads/feature/*');
-      expect(specs[3]?.pattern).toBe('refs/heads/feature/old-*');
-    });
-  });
-
-  describe('convertWildcardToRegex', () => {
-    it('should convert single wildcard', () => {
-      const regex = parser.convertWildcardToRegex('refs/heads/*');
-
-      expect(regex.test('refs/heads/main')).toBe(true);
-      expect(regex.test('refs/heads/feature')).toBe(true);
-      expect(regex.test('refs/heads/feature/nested')).toBe(false);
-    });
-
-    it('should convert double wildcard', () => {
-      const regex = parser.convertWildcardToRegex('refs/heads/**');
-
-      expect(regex.test('refs/heads/main')).toBe(true);
-      expect(regex.test('refs/heads/feature/nested/deep')).toBe(true);
-    });
-
-    it('should escape special regex characters', () => {
-      const regex = parser.convertWildcardToRegex('refs/heads/feature.test');
-
-      expect(regex.test('refs/heads/feature.test')).toBe(true);
-      expect(regex.test('refs/heads/featurextest')).toBe(false);
-    });
-
-    it('should handle multiple wildcards', () => {
-      const regex = parser.convertWildcardToRegex('refs/*/feature-*');
-
-      expect(regex.test('refs/heads/feature-123')).toBe(true);
-      expect(regex.test('refs/remotes/feature-456')).toBe(true);
-      expect(regex.test('refs/heads/main')).toBe(false);
-    });
-  });
-
-  describe('extractDefaultBranch', () => {
-    it('should extract default branch from specs', () => {
-      const specs: BranchSpec[] = [
-        { pattern: 'refs/heads/develop', type: 'include', isDefault: false, regex: /.*/ },
-        { pattern: 'refs/heads/main', type: 'include', isDefault: true, regex: /.*/ },
-        { pattern: 'refs/heads/feature/*', type: 'include', isDefault: false, regex: /.*/ },
-      ];
-
-      const defaultBranch = parser.extractDefaultBranch(specs);
-
-      expect(defaultBranch).toBe('refs/heads/main');
-    });
-
-    it('should return null if no default branch', () => {
-      const specs: BranchSpec[] = [
-        { pattern: 'refs/heads/develop', type: 'include', isDefault: false, regex: /.*/ },
-        { pattern: 'refs/heads/main', type: 'include', isDefault: false, regex: /.*/ },
-      ];
-
-      const defaultBranch = parser.extractDefaultBranch(specs);
-
-      expect(defaultBranch).toBeNull();
-    });
-
-    it('should handle <default> placeholder', () => {
-      const specs: BranchSpec[] = [
-        { pattern: '<default>', type: 'include', isDefault: true, regex: /.*/ },
-      ];
-
-      const defaultBranch = parser.extractDefaultBranch(specs);
-
-      expect(defaultBranch).toBe('<default>');
-    });
-  });
-});
-
-describe('BranchMatcher', () => {
-  let matcher: BranchMatcher;
-  let parser: BranchSpecificationParser;
-
-  beforeEach(() => {
-    parser = new BranchSpecificationParser();
-    matcher = new BranchMatcher(parser);
-  });
-
-  describe('matchBranch', () => {
-    it('should match branch against single specification', () => {
-      const specs = parser.parseMultipleSpecifications(['+:refs/heads/*']);
-
-      expect(matcher.matchBranch('refs/heads/main', specs)).toBe(true);
-      expect(matcher.matchBranch('refs/tags/v1.0', specs)).toBe(false);
-    });
-
-    it('should respect exclusion rules', () => {
-      const specs = parser.parseMultipleSpecifications([
-        '+:refs/heads/*',
-        '-:refs/heads/experimental/*',
-      ]);
-
-      expect(matcher.matchBranch('refs/heads/main', specs)).toBe(true);
-      expect(matcher.matchBranch('refs/heads/experimental/feature', specs)).toBe(false);
-    });
-
-    it('should apply rules in order', () => {
-      const specs = parser.parseMultipleSpecifications([
-        '+:refs/heads/*',
-        '-:refs/heads/feature/*',
-        '+:refs/heads/feature/important',
-      ]);
-
-      expect(matcher.matchBranch('refs/heads/main', specs)).toBe(true);
-      expect(matcher.matchBranch('refs/heads/feature/test', specs)).toBe(false);
-      expect(matcher.matchBranch('refs/heads/feature/important', specs)).toBe(true);
-    });
-
-    it('should handle no matching rules', () => {
-      const specs = parser.parseMultipleSpecifications(['+:refs/heads/*']);
-
-      expect(matcher.matchBranch('refs/tags/v1.0', specs)).toBe(false);
-    });
-
-    it('should handle empty specifications', () => {
-      expect(matcher.matchBranch('refs/heads/main', [])).toBe(false);
-    });
-  });
-
-  describe('getMatchingConfigurations', () => {
-    it('should find configurations that match a branch', () => {
-      const configurations = [
-        {
-          id: 'config1',
-          name: 'Main Build',
-          branchSpecs: ['+:refs/heads/main', '+:refs/heads/develop'],
-        },
-        {
-          id: 'config2',
-          name: 'Feature Build',
-          branchSpecs: ['+:refs/heads/feature/*', '-:refs/heads/feature/experimental/*'],
-        },
-        {
-          id: 'config3',
-          name: 'Release Build',
-          branchSpecs: ['+:refs/heads/release/*', '+:refs/tags/*'],
-        },
-      ];
-
-      const mainMatches = matcher.getMatchingConfigurations('refs/heads/main', configurations);
-      expect(mainMatches).toEqual([
-        {
-          configId: 'config1',
-          configName: 'Main Build',
-          matchedSpec: 'refs/heads/main',
-          confidence: 1.0,
-        },
-      ]);
-
-      const featureMatches = matcher.getMatchingConfigurations(
-        'refs/heads/feature/new-ui',
-        configurations
-      );
-      expect(featureMatches).toEqual([
-        {
-          configId: 'config2',
-          configName: 'Feature Build',
-          matchedSpec: 'refs/heads/feature/*',
-          confidence: 0.8,
-        },
-      ]);
-
-      const experimentalMatches = matcher.getMatchingConfigurations(
-        'refs/heads/feature/experimental/test',
-        configurations
-      );
-      expect(experimentalMatches).toEqual([]);
-    });
-
-    it('should calculate confidence scores', () => {
-      const configurations = [
-        {
-          id: 'config1',
-          name: 'Exact Match',
-          branchSpecs: ['+:refs/heads/main'],
-        },
-        {
-          id: 'config2',
-          name: 'Wildcard Match',
-          branchSpecs: ['+:refs/heads/*'],
-        },
-        {
-          id: 'config3',
-          name: 'Deep Wildcard',
-          branchSpecs: ['+:refs/**'],
-        },
-      ];
-
-      const matches = matcher.getMatchingConfigurations('refs/heads/main', configurations);
-
-      expect(matches).toHaveLength(3);
-      expect(matches[0]?.confidence).toBe(1.0); // Exact match
-      expect(matches[1]?.confidence).toBe(0.8); // Single wildcard
-      expect(matches[2]?.confidence).toBe(0.6); // Double wildcard
-    });
-  });
-
-  describe('getBranchesForConfiguration', () => {
-    it('should extract potential branches from specifications', () => {
-      const specs = [
-        '+:refs/heads/main',
-        '+:refs/heads/develop',
-        '+:refs/heads/feature/*',
-        '-:refs/heads/feature/old-*',
-      ];
-
-      const branches = matcher.getBranchesForConfiguration(specs);
-
-      expect(branches).toContain('refs/heads/main');
-      expect(branches).toContain('refs/heads/develop');
-      expect(branches.some((b) => b.includes('feature/*'))).toBe(true);
-    });
-
-    it('should identify default branch', () => {
-      const specs = [
-        '+:refs/heads/main (default)',
-        '+:refs/heads/develop',
-        '+:refs/heads/feature/*',
-      ];
-
-      // We only need default branch here
-      const defaultBranch = parser.extractDefaultBranch(parser.parseMultipleSpecifications(specs));
-
-      expect(defaultBranch).toBe('refs/heads/main');
-    });
-  });
-});

package/tests/unit/teamcity/build-config-navigator-more.test.ts

@@ -1,245 +0,0 @@
-import { BuildConfigNavigator } from '@/teamcity/build-config-navigator';
-import type { TeamCityClient } from '@/teamcity/client';
-
-describe('BuildConfigNavigator (more branches)', () => {
-  let navigator: BuildConfigNavigator;
-  type MockClient = {
-    buildTypes: { getAllBuildTypes: jest.Mock };
-    projects: { getProject: jest.Mock };
-  };
-  let mockClient: MockClient;
-
-  beforeEach(() => {
-    mockClient = {
-      buildTypes: { getAllBuildTypes: jest.fn() },
-      projects: { getProject: jest.fn() },
-    };
-    navigator = new BuildConfigNavigator(mockClient as unknown as TeamCityClient);
-    // clear cache
-    type PrivateNav = { cache: Map<string, unknown> };
-    (navigator as unknown as PrivateNav).cache.clear();
-  });
-
-  it('extracts parameters when includeParameters is true', async () => {
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: {
-        count: 1,
-        buildType: [
-          {
-            id: 'B1',
-            name: 'With Params',
-            projectId: 'P',
-            projectName: 'Proj',
-            parameters: {
-              property: [
-                { name: 'env.FOO', value: 'bar' },
-                { name: 'system.debug', value: 'true' },
-              ],
-            },
-          },
-        ],
-      },
-    });
-
-    const res = await navigator.listBuildConfigs({ includeParameters: true });
-    expect(res.buildConfigs[0]?.parameters).toEqual({ 'env.FOO': 'bar', 'system.debug': 'true' });
-  });
-
-  it('extracts project hierarchy when includeProjectHierarchy is true', async () => {
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: {
-        count: 1,
-        buildType: [{ id: 'B1', name: 'With Hier', projectId: 'P2', projectName: 'Project 2' }],
-      },
-    });
-    // parent chain: _Root -> P1 -> P2
-    mockClient.projects.getProject.mockImplementation(async (id: string) => {
-      if (id === 'P2') {
-        return {
-          data: {
-            id: 'P2',
-            name: 'Project 2',
-            parentProject: {
-              id: 'P1',
-              name: 'Project 1',
-              parentProject: { id: '_Root', name: 'Root' },
-            },
-          },
-        };
-      }
-      return { data: { id, name: id } };
-    });
-
-    const res = await navigator.listBuildConfigs({ includeProjectHierarchy: true });
-    expect(res.buildConfigs[0]?.projectHierarchy).toEqual([
-      { id: '_Root', name: 'Root' },
-      { id: 'P1', name: 'Project 1' },
-      { id: 'P2', name: 'Project 2' },
-    ]);
-  });
-
-  it('applies statusFilter on lastBuildStatus, paused, hasRecentActivity and activeSince', async () => {
-    const buildType = (
-      overrides: Partial<{ lastBuildStatus: string; paused: boolean; lastBuildDate: string }>
-    ) => ({
-      id: 'B',
-      name: 'N',
-      projectId: 'P',
-      projectName: 'Proj',
-      ...overrides,
-    });
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: {
-        count: 4,
-        buildType: [
-          buildType({
-            lastBuildStatus: 'SUCCESS',
-            paused: false,
-            lastBuildDate: '2025-01-02T00:00:00Z',
-          }),
-          buildType({
-            lastBuildStatus: 'FAILURE',
-            paused: true,
-            lastBuildDate: '2025-01-01T00:00:00Z',
-          }),
-          buildType({ lastBuildStatus: 'SUCCESS', paused: true }), // no lastBuildDate
-          buildType({
-            lastBuildStatus: 'SUCCESS',
-            paused: false,
-            lastBuildDate: '2024-12-31T00:00:00Z',
-          }),
-        ],
-      },
-    });
-
-    // Filter: only SUCCESS, not paused, has recent activity since Jan 1, 2025
-    const res = await navigator.listBuildConfigs({
-      statusFilter: {
-        lastBuildStatus: 'SUCCESS',
-        paused: false,
-        hasRecentActivity: true,
-        activeSince: new Date('2025-01-01T00:00:00Z'),
-      },
-    });
-    expect(res.buildConfigs).toHaveLength(1);
-    expect(res.buildConfigs[0]?.lastBuildDate).toBe('2025-01-02T00:00:00Z');
-  });
-
-  it('filters by vcsRootFilter url/branch/vcsName and handles missing roots', async () => {
-    const make = (url?: string, branch?: string, vcsName: string = 'git') => ({
-      id: 'B',
-      name: 'N',
-      projectId: 'P',
-      projectName: 'Proj',
-      'vcs-root-entries': {
-        'vcs-root-entry': [
-          {
-            'vcs-root': {
-              id: 'R',
-              name: 'Repo',
-              vcsName,
-              properties: {
-                property: [
-                  { name: 'url', value: url },
-                  { name: 'branch', value: branch },
-                ],
-              },
-            },
-          },
-        ],
-      },
-    });
-
-    // Two configs: only the second matches url and branch
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: {
-        count: 2,
-        buildType: [make('https://a', 'main'), make('https://match', 'dev')],
-      },
-    });
-
-    const res = await navigator.listBuildConfigs({
-      includeVcsRoots: true,
-      vcsRootFilter: { url: 'match', branch: 'dev', vcsName: 'git' },
-    });
-    expect(res.buildConfigs).toHaveLength(1);
-
-    // No roots present → filter cannot apply; item passes through
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: { count: 1, buildType: [{ id: 'X', name: 'X' }] },
-    });
-    const res2 = await navigator.listBuildConfigs({
-      includeVcsRoots: true,
-      vcsRootFilter: { url: 'x' },
-    });
-    expect(res2.buildConfigs).toHaveLength(1);
-  });
-
-  it('sorts by project then name, and lastModified combinations', async () => {
-    const b = (name: string, projectName: string, last?: string) => ({
-      id: name,
-      name,
-      projectId: projectName,
-      projectName,
-      lastBuildDate: last,
-    });
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: {
-        count: 4,
-        buildType: [b('B', 'P1'), b('A', 'P1'), b('C', 'P2', '2025-01-01'), b('D', 'P3')],
-      },
-    });
-
-    // Sort by project with tiebreaker on name
-    const res = await navigator.listBuildConfigs({ sortBy: 'project', sortOrder: 'asc' });
-    expect(res.buildConfigs.map((x) => x.name)).toEqual(['A', 'B', 'C', 'D']);
-
-    // Sort by lastModified with missing values: current impl places entries without dates first for desc
-    const res2 = await navigator.listBuildConfigs({ sortBy: 'lastModified', sortOrder: 'desc' });
-    expect(['A', 'B', 'D']).toContain(res2.buildConfigs[0]?.name);
-    expect(res2.buildConfigs.map((x) => x.name)).toContain('C');
-  });
-
-  it('calculateHasMore returns false if limit missing or count below limit', async () => {
-    mockClient.buildTypes.getAllBuildTypes.mockResolvedValue({
-      data: { count: 3, buildType: [{ id: '1', name: '1' }] },
-    });
-    const res = await navigator.listBuildConfigs();
-    expect(res.hasMore).toBe(false);
-
-    const res2 = await navigator.listBuildConfigs({ pagination: { limit: 10, offset: 0 } });
-    expect(res2.hasMore).toBe(false);
-  });
-
-  it('transformError covers various cases (401/403/404/timeout/5xx/generic)', async () => {
-    const err401 = { response: { status: 401 } };
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(err401);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/Authentication failed/);
-
-    const err403 = { response: { status: 403 } };
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(err403);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/Permission denied/);
-
-    const err404 = { response: { status: 404 } };
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(err404);
-    await expect(navigator.listBuildConfigs({ projectId: 'P' })).rejects.toThrow(
-      /Project P not found/
-    );
-
-    const timeoutByName = { name: 'ECONNABORTED' };
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(timeoutByName);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/Request timed out/);
-
-    const timeoutByMessage = new Error('socket timeout');
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(timeoutByMessage);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/Request timed out/);
-
-    const serverErr = { response: { status: 500 }, message: 'Internal' };
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(serverErr);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/TeamCity API error/);
-
-    const genericErr = new Error('oops');
-    mockClient.buildTypes.getAllBuildTypes.mockRejectedValueOnce(genericErr);
-    await expect(navigator.listBuildConfigs()).rejects.toThrow(/oops/);
-  });
-});