@daghis/teamcity-mcp 0.9.0 → 0.9.2

package/tests/unit/swagger/swagger-manager.test.ts

@@ -1,89 +0,0 @@
-import { SwaggerManager } from '@/swagger';
-import { SwaggerCache } from '@/swagger/swagger-cache';
-import { SwaggerFetcher, type SwaggerSpec } from '@/swagger/swagger-fetcher';
-import { SwaggerValidator } from '@/swagger/swagger-validator';
-
-jest.mock('@/config', () => ({
-  getConfig: () => ({ teamcity: { url: 'https://teamcity.example.com', token: 't' } }),
-}));
-
-describe('SwaggerManager', () => {
-  const spec: SwaggerSpec = {
-    openapi: '3.0.0',
-    info: { version: '2024.1', title: 'API' },
-    paths: {},
-  };
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.clearAllMocks();
-  });
-
-  it('returns cached spec when available', async () => {
-    jest.spyOn(SwaggerCache.prototype, 'get').mockResolvedValueOnce(spec);
-    const fetchSpy = jest.spyOn(SwaggerFetcher.prototype, 'fetchSpec');
-
-    const mgr = new SwaggerManager({});
-    const out = await mgr.getSpec();
-    expect(out).toEqual(spec);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it('fetches, validates, warns, and caches when not cached', async () => {
-    jest.spyOn(SwaggerCache.prototype, 'get').mockResolvedValueOnce(null as unknown as SwaggerSpec);
-    jest.spyOn(SwaggerFetcher.prototype, 'fetchSpec').mockResolvedValueOnce(spec);
-    jest
-      .spyOn(SwaggerValidator.prototype, 'validateSpec')
-      .mockReturnValueOnce({ isValid: true, teamCityVersion: '2024.1', version: '3.0.0' });
-    const setSpy = jest.spyOn(SwaggerCache.prototype, 'set').mockResolvedValueOnce();
-
-    const mgr = new SwaggerManager({});
-    const out = await mgr.getSpec();
-    expect(out).toEqual(spec);
-    expect(setSpy).toHaveBeenCalled();
-  });
-
-  it('getServerInfo returns connectivity, version and specVersion', async () => {
-    jest.spyOn(SwaggerFetcher.prototype, 'testConnection').mockResolvedValueOnce(true);
-    jest.spyOn(SwaggerFetcher.prototype, 'getServerVersion').mockResolvedValueOnce('2024.1');
-    jest.spyOn(SwaggerCache.prototype, 'get').mockResolvedValueOnce(spec);
-
-    const mgr = new SwaggerManager({});
-    const info = await mgr.getServerInfo();
-    expect(info.connected).toBe(true);
-    expect(info.version).toBe('2024.1');
-    expect(info.specVersion).toBe('3.0.0');
-  });
-
-  it('getServerInfo handles spec fetch errors gracefully', async () => {
-    jest.spyOn(SwaggerFetcher.prototype, 'testConnection').mockResolvedValueOnce(false);
-    jest.spyOn(SwaggerFetcher.prototype, 'getServerVersion').mockResolvedValueOnce(null);
-    jest.spyOn(SwaggerCache.prototype, 'get').mockResolvedValueOnce(null as unknown as SwaggerSpec);
-    jest.spyOn(SwaggerFetcher.prototype, 'fetchSpec').mockRejectedValueOnce(new Error('x'));
-
-    const mgr = new SwaggerManager({});
-    const info = await mgr.getServerInfo();
-    expect(info.connected).toBe(false);
-    expect(info.version).toBeNull();
-    expect(info.specVersion).toBeUndefined();
-  });
-
-  it('clearCache delegates to cache', async () => {
-    const spy = jest.spyOn(SwaggerCache.prototype, 'clear').mockResolvedValueOnce();
-    const mgr = new SwaggerManager({});
-    await mgr.clearCache();
-    expect(spy).toHaveBeenCalled();
-  });
-
-  it('getCacheStats delegates to cache', async () => {
-    const stats = { size: 1, files: 1 };
-    jest.spyOn(SwaggerCache.prototype, 'getStats').mockResolvedValueOnce(
-      stats as unknown as {
-        size: number;
-        files: number;
-      }
-    );
-    const mgr = new SwaggerManager({});
-    await expect(mgr.getCacheStats()).resolves.toEqual(stats);
-  });
-});

package/tests/unit/teamcity/artifact-manager.test.ts

@@ -1,450 +0,0 @@
-/**
- * Tests for ArtifactManager
- */
-import axios from 'axios';
-
-import * as config from '@/config';
-import { ArtifactManager } from '@/teamcity/artifact-manager';
-
-jest.mock('axios');
-jest.mock('@/config');
-
-describe('ArtifactManager', () => {
-  let manager: ArtifactManager;
-  const mockAxios = axios as jest.Mocked<typeof axios>;
-  const mockConfig = config as jest.Mocked<typeof config>;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    // Reset config mocks with proper values
-    mockConfig.getTeamCityUrl.mockReturnValue('https://teamcity.example.com');
-    mockConfig.getTeamCityToken.mockReturnValue('test-token');
-    manager = new ArtifactManager();
-  });
-
-  describe('Artifact Listing', () => {
-    it('should list all artifacts for a build', async () => {
-      const mockArtifacts = {
-        file: [
-          {
-            name: 'app.jar',
-            fullName: 'target/app.jar',
-            size: 10485760,
-            modificationTime: '20250829T121400+0000',
-            href: '/app/rest/builds/id:12345/artifacts/metadata/target/app.jar',
-            content: { href: '/app/rest/builds/id:12345/artifacts/content/target/app.jar' },
-          },
-          {
-            name: 'test-report.html',
-            fullName: 'reports/test-report.html',
-            size: 524288,
-            modificationTime: '20250829T121430+0000',
-            href: '/app/rest/builds/id:12345/artifacts/metadata/reports/test-report.html',
-            content: {
-              href: '/app/rest/builds/id:12345/artifacts/content/reports/test-report.html',
-            },
-          },
-        ],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      const result = await manager.listArtifacts('12345');
-
-      // Behavior-first: avoid asserting internal HTTP call shape
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe('app.jar');
-      expect(result[0]?.path).toBe('target/app.jar');
-      expect(result[0]?.size).toBe(10485760);
-      expect(result[0]?.downloadUrl).toContain('/artifacts/content/target/app.jar');
-    });
-
-    it('should handle nested artifact directories', async () => {
-      const mockArtifacts = {
-        file: [
-          {
-            name: 'libs',
-            fullName: 'build/libs',
-            size: 0,
-            href: '/app/rest/builds/id:12345/artifacts/metadata/build/libs',
-            children: {
-              file: [
-                {
-                  name: 'core.jar',
-                  fullName: 'build/libs/core.jar',
-                  size: 2097152,
-                },
-                {
-                  name: 'utils.jar',
-                  fullName: 'build/libs/utils.jar',
-                  size: 1048576,
-                },
-              ],
-            },
-          },
-        ],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      const result = await manager.listArtifacts('12345', { includeNested: true });
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.path).toBe('build/libs/core.jar');
-      expect(result[1]?.path).toBe('build/libs/utils.jar');
-    });
-
-    it('should paginate large artifact lists', async () => {
-      const mockArtifacts = {
-        file: new Array(150).fill(null).map((_, i) => ({
-          name: `file${i}.txt`,
-          fullName: `files/file${i}.txt`,
-          size: 1024,
-          modificationTime: '20250829T120000+0000',
-        })),
-        nextHref: '/app/rest/builds/id:12345/artifacts?start=100',
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      const result = await manager.listArtifacts('12345', {
-        limit: 100,
-        offset: 0,
-      });
-
-      expect(result).toHaveLength(100);
-      expect(result[0]?.name).toBe('file0.txt');
-      expect(result[99]?.name).toBe('file99.txt');
-    });
-  });
-
-  describe('Artifact Filtering', () => {
-    const mockArtifacts = {
-      file: [
-        { name: 'app.jar', fullName: 'target/app.jar', size: 10485760 },
-        { name: 'lib.jar', fullName: 'target/lib.jar', size: 2097152 },
-        { name: 'test-report.html', fullName: 'reports/test-report.html', size: 524288 },
-        { name: 'coverage.xml', fullName: 'reports/coverage.xml', size: 102400 },
-        { name: 'README.md', fullName: 'README.md', size: 5120 },
-      ],
-    };
-
-    beforeEach(() => {
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-    });
-
-    it('should filter artifacts by name pattern', async () => {
-      const result = await manager.listArtifacts('12345', {
-        nameFilter: '*.jar',
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe('app.jar');
-      expect(result[1]?.name).toBe('lib.jar');
-    });
-
-    it('should filter artifacts by path prefix', async () => {
-      const result = await manager.listArtifacts('12345', {
-        pathFilter: 'reports/*',
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe('test-report.html');
-      expect(result[1]?.name).toBe('coverage.xml');
-    });
-
-    it('should filter artifacts by extension', async () => {
-      const result = await manager.listArtifacts('12345', {
-        extension: 'jar',
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result.every((a) => a.name.endsWith('.jar'))).toBe(true);
-    });
-
-    it('should filter artifacts by size range', async () => {
-      const result = await manager.listArtifacts('12345', {
-        minSize: 100000,
-        maxSize: 1000000,
-      });
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.name).toBe('test-report.html');
-      expect(result[1]?.name).toBe('coverage.xml');
-    });
-
-    it('should combine multiple filters', async () => {
-      const result = await manager.listArtifacts('12345', {
-        pathFilter: 'reports/*',
-        extension: 'xml',
-      });
-
-      expect(result).toHaveLength(1);
-      expect(result[0]?.name).toBe('coverage.xml');
-    });
-  });
-
-  describe('Artifact Download', () => {
-    it('should generate download URLs', async () => {
-      const mockArtifacts = {
-        file: [{ name: 'app.jar', fullName: 'target/app.jar', size: 10485760 }],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      const result = await manager.listArtifacts('12345');
-
-      expect(result[0]?.downloadUrl).toBe(
-        'https://teamcity.example.com/app/rest/builds/id:12345/artifacts/content/target/app.jar'
-      );
-    });
-
-    it('should download artifact content as base64', async () => {
-      const mockContent = 'Hello, World!';
-      const base64Content = Buffer.from(mockContent).toString('base64');
-
-      mockAxios.get
-        .mockResolvedValueOnce({
-          data: {
-            file: [{ name: 'hello.txt', fullName: 'hello.txt', size: 13 }],
-          },
-        })
-        .mockResolvedValueOnce({
-          data: mockContent,
-          headers: { 'content-type': 'text/plain' },
-        });
-
-      const result = await manager.downloadArtifact('12345', 'hello.txt', {
-        encoding: 'base64',
-      });
-
-      expect(result.content).toBe(base64Content);
-      expect(result.mimeType).toBe('text/plain');
-      expect(result.size).toBe(13);
-    });
-
-    it('should download artifact content as text', async () => {
-      const mockContent = 'Hello, World!';
-
-      mockAxios.get
-        .mockResolvedValueOnce({
-          data: {
-            file: [{ name: 'hello.txt', fullName: 'hello.txt', size: 13 }],
-          },
-        })
-        .mockResolvedValueOnce({
-          data: mockContent,
-          headers: { 'content-type': 'text/plain' },
-        });
-
-      const result = await manager.downloadArtifact('12345', 'hello.txt', {
-        encoding: 'text',
-      });
-
-      expect(result.content).toBe(mockContent);
-    });
-
-    it('should handle binary artifacts', async () => {
-      const binaryData = Buffer.from([0x89, 0x50, 0x4e, 0x47]); // PNG header
-
-      mockAxios.get
-        .mockResolvedValueOnce({
-          data: {
-            file: [{ name: 'image.png', fullName: 'image.png', size: 4 }],
-          },
-        })
-        .mockResolvedValueOnce({
-          data: binaryData,
-          headers: { 'content-type': 'image/png' },
-        });
-
-      const result = await manager.downloadArtifact('12345', 'image.png', {
-        encoding: 'base64',
-      });
-
-      expect(result.content).toBe(binaryData.toString('base64'));
-      expect(result.mimeType).toBe('image/png');
-    });
-
-    it('should respect size limits', async () => {
-      mockAxios.get.mockResolvedValueOnce({
-        data: {
-          file: [{ name: 'large.bin', fullName: 'large.bin', size: 10485760 }],
-        },
-      });
-
-      await expect(
-        manager.downloadArtifact('12345', 'large.bin', {
-          maxSize: 1048576, // 1MB limit
-        })
-      ).rejects.toThrow('Artifact size exceeds maximum allowed size');
-    });
-  });
-
-  describe('Batch Operations', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    it('should download multiple artifacts', async () => {
-      const mockArtifacts = {
-        file: [
-          { name: 'file1.txt', fullName: 'file1.txt', size: 10 },
-          { name: 'file2.txt', fullName: 'file2.txt', size: 20 },
-          { name: 'file3.txt', fullName: 'file3.txt', size: 30 },
-        ],
-      };
-
-      // Since Promise.allSettled runs in parallel, all listArtifacts calls happen first,
-      // then all download calls happen
-      mockAxios.get
-        .mockResolvedValueOnce({ data: mockArtifacts }) // listArtifacts for file1
-        .mockResolvedValueOnce({ data: mockArtifacts }) // listArtifacts for file2
-        .mockResolvedValueOnce({ data: mockArtifacts }) // listArtifacts for file3
-        .mockResolvedValueOnce({ data: Buffer.from('content1'), headers: {} }) // download file1
-        .mockResolvedValueOnce({ data: Buffer.from('content2'), headers: {} }) // download file2
-        .mockResolvedValueOnce({ data: Buffer.from('content3'), headers: {} }); // download file3
-
-      const result = await manager.downloadMultipleArtifacts('12345', [
-        'file1.txt',
-        'file2.txt',
-        'file3.txt',
-      ]);
-
-      expect(result).toHaveLength(3);
-      expect(result[0]?.name).toBe('file1.txt');
-      expect(result[0]?.content).toBe(Buffer.from('content1').toString('base64'));
-      expect(result[1]?.name).toBe('file2.txt');
-      expect(result[1]?.content).toBe(Buffer.from('content2').toString('base64'));
-      expect(result[2]?.name).toBe('file3.txt');
-      expect(result[2]?.content).toBe(Buffer.from('content3').toString('base64'));
-    });
-
-    it('should handle partial batch download failures', async () => {
-      const mockArtifacts = {
-        file: [
-          { name: 'file1.txt', fullName: 'file1.txt', size: 10 },
-          { name: 'file2.txt', fullName: 'file2.txt', size: 20 },
-        ],
-      };
-
-      // Since Promise.allSettled runs in parallel, all listArtifacts calls happen first
-      mockAxios.get
-        .mockResolvedValueOnce({ data: mockArtifacts }) // listArtifacts for file1
-        .mockResolvedValueOnce({ data: mockArtifacts }) // listArtifacts for file2
-        .mockResolvedValueOnce({ data: Buffer.from('content1'), headers: {} }) // download file1
-        .mockRejectedValueOnce(new Error('Download failed')); // download file2 fails
-
-      const result = await manager.downloadMultipleArtifacts('12345', ['file1.txt', 'file2.txt']);
-
-      expect(result).toHaveLength(2);
-      expect(result[0]?.content).toBe(Buffer.from('content1').toString('base64'));
-      expect(result[1]?.error).toBe('Failed to download artifact: Download failed');
-    });
-  });
-
-  describe('Error Handling', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-      // Create a fresh manager instance to avoid cache issues
-      manager = new ArtifactManager();
-    });
-
-    it('should handle network errors', async () => {
-      mockAxios.get.mockRejectedValue(new Error('Network error'));
-
-      await expect(manager.listArtifacts('12345')).rejects.toThrow('Failed to fetch artifacts');
-    });
-
-    it('should handle authentication errors', async () => {
-      const error = new Error('Unauthorized') as Error & {
-        response?: { status: number; data: string };
-      };
-      error.response = { status: 401, data: 'Unauthorized' };
-      mockAxios.get.mockRejectedValue(error);
-
-      await expect(manager.listArtifacts('12345')).rejects.toThrow('Authentication failed');
-    });
-
-    it('should handle missing artifacts', async () => {
-      mockAxios.get.mockResolvedValue({ data: { file: [] } });
-
-      const result = await manager.listArtifacts('12345');
-      expect(result).toEqual([]);
-    });
-
-    it('should handle artifact not found during download', async () => {
-      mockAxios.get.mockResolvedValueOnce({
-        data: { file: [] },
-      });
-
-      await expect(manager.downloadArtifact('12345', 'nonexistent.txt')).rejects.toThrow(
-        'Artifact not found'
-      );
-    });
-  });
-
-  describe('Caching', () => {
-    it('should cache artifact listings', async () => {
-      const mockArtifacts = {
-        file: [{ name: 'app.jar', fullName: 'target/app.jar', size: 10485760 }],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      // First call
-      const first = await manager.listArtifacts('12345');
-      expect(mockAxios.get).toHaveBeenCalledTimes(1);
-      // Second call should produce same results
-      const second = await manager.listArtifacts('12345');
-      expect(second).toEqual(first);
-      // Ensure cache prevented additional HTTP call
-      expect(mockAxios.get).toHaveBeenCalledTimes(1);
-    });
-
-    it('should respect cache TTL', async () => {
-      jest.useFakeTimers();
-
-      const mockArtifacts = {
-        file: [{ name: 'app.jar', fullName: 'target/app.jar', size: 10485760 }],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      // First call
-      await manager.listArtifacts('12345');
-
-      // Advance time by 59 seconds (within TTL)
-      jest.advanceTimersByTime(59000);
-      await manager.listArtifacts('12345');
-
-      // Behavior-first: still returns same results within TTL
-
-      // Advance time by 2 more seconds (exceeds TTL)
-      jest.advanceTimersByTime(2000);
-      await manager.listArtifacts('12345');
-
-      // Behavior-first: returns results after TTL
-      expect(mockAxios.get).toHaveBeenCalledTimes(2);
-
-      jest.useRealTimers();
-    });
-
-    it('should bypass cache with force refresh', async () => {
-      const mockArtifacts = {
-        file: [{ name: 'app.jar', fullName: 'target/app.jar', size: 10485760 }],
-      };
-
-      mockAxios.get.mockResolvedValue({ data: mockArtifacts });
-
-      // First call
-      await manager.listArtifacts('12345');
-      // Second call with force refresh
-      const r2 = await manager.listArtifacts('12345', { forceRefresh: true });
-      expect(Array.isArray(r2)).toBe(true);
-      // Should have made two HTTP calls due to bypassing cache
-      expect(mockAxios.get).toHaveBeenCalledTimes(2);
-    });
-  });
-});