@daghis/teamcity-mcp 0.1.2

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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,450 @@
+/**
+ * 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);
+    });
+  });
+});