@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/swagger/swagger-fetcher.test.ts

@@ -1,619 +0,0 @@
-/**
- * Tests for TeamCity Swagger specification fetching and validation
- */
-import axios from 'axios';
-import type { Stats } from 'fs';
-import * as fsPromises from 'fs/promises';
-
-import { SwaggerCache } from '@/swagger/swagger-cache';
-import { SwaggerFetcher } from '@/swagger/swagger-fetcher';
-import { SwaggerValidator } from '@/swagger/swagger-validator';
-
-// Mock modules
-jest.mock('axios');
-// Mock fs/promises at module level since its properties are non-configurable
-jest.mock('fs/promises', () => ({
-  mkdir: jest.fn(),
-  readFile: jest.fn(),
-  writeFile: jest.fn(),
-  access: jest.fn(),
-  readdir: jest.fn(),
-  unlink: jest.fn(),
-  rm: jest.fn(),
-  stat: jest.fn(),
-}));
-
-describe('SwaggerFetcher', () => {
-  let fetcher: SwaggerFetcher;
-  type MockAxiosInstance = {
-    get: jest.Mock;
-    post: jest.Mock;
-    defaults: Record<string, unknown>;
-  };
-  let mockAxiosInstance: MockAxiosInstance;
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.clearAllMocks();
-
-    // Mock axios instance
-    mockAxiosInstance = {
-      get: jest.fn(),
-      post: jest.fn(),
-      defaults: {},
-    };
-
-    // Mock axios.create to return our mock instance
-    const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
-    mockedAxios.create = jest.fn().mockReturnValue(mockAxiosInstance);
-    // Provide a properly typed predicate for isAxiosError
-    (mockedAxios as unknown as { isAxiosError: typeof axios.isAxiosError }).isAxiosError = jest.fn(
-      () => false
-    ) as unknown as typeof axios.isAxiosError;
-
-    fetcher = new SwaggerFetcher({
-      baseUrl: 'https://teamcity.example.com',
-      token: 'test-token',
-    });
-  });
-
-  describe('fetchSpec', () => {
-    it('should fetch Swagger spec from TeamCity API', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: {
-          version: '2023.11',
-          title: 'TeamCity REST API',
-        },
-        paths: {},
-      };
-
-      mockAxiosInstance.get.mockResolvedValueOnce({
-        data: mockSpec,
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      });
-
-      const spec = await fetcher.fetchSpec();
-      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/app/rest/swagger.json');
-      expect(spec).toEqual(mockSpec);
-    });
-
-    it('should handle OpenAPI 3.0 specifications', async () => {
-      const mockSpec = {
-        openapi: '3.0.0',
-        info: {
-          version: '2024.1',
-          title: 'TeamCity REST API',
-        },
-        paths: {},
-      };
-
-      mockAxiosInstance.get.mockResolvedValueOnce({
-        data: mockSpec,
-        status: 200,
-      });
-
-      const spec = await fetcher.fetchSpec();
-      expect(spec).toEqual(mockSpec);
-    });
-
-    it('should throw error on network failure', async () => {
-      mockAxiosInstance.get.mockRejectedValueOnce(new Error('Network error'));
-
-      await expect(fetcher.fetchSpec()).rejects.toThrow('Failed to fetch TeamCity Swagger spec');
-    });
-
-    it('should throw error on non-200 status', async () => {
-      mockAxiosInstance.get.mockResolvedValueOnce({
-        data: {},
-        status: 401,
-        statusText: 'Unauthorized',
-      });
-
-      await expect(fetcher.fetchSpec()).rejects.toThrow('Failed to fetch Swagger spec: 401');
-    });
-
-    it('should handle timeout appropriately', async () => {
-      const timeoutError = new Error('timeout') as Error & { code?: string };
-      timeoutError.code = 'ECONNABORTED';
-      mockAxiosInstance.get.mockRejectedValueOnce(timeoutError);
-
-      const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
-      (mockedAxios as unknown as { isAxiosError: typeof axios.isAxiosError }).isAxiosError =
-        jest.fn(() => true) as unknown as typeof axios.isAxiosError;
-
-      await expect(fetcher.fetchSpec()).rejects.toThrow('timeout');
-    });
-
-    it('should map axios 401 error to Authentication failed', async () => {
-      const axiosErr: Error & { response?: { status: number } } = Object.assign(
-        new Error('Unauthorized'),
-        { response: { status: 401 } }
-      );
-
-      const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
-      (mockedAxios as unknown as { isAxiosError: typeof axios.isAxiosError }).isAxiosError =
-        jest.fn(() => true) as unknown as typeof axios.isAxiosError;
-
-      mockAxiosInstance.get.mockRejectedValueOnce(axiosErr);
-
-      await expect(fetcher.fetchSpec()).rejects.toThrow('Authentication failed');
-    });
-
-    it('should map axios 404 error to Endpoint not found', async () => {
-      const axiosErr: Error & { response?: { status: number } } = Object.assign(
-        new Error('Not Found'),
-        { response: { status: 404 } }
-      );
-
-      const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
-      (mockedAxios as unknown as { isAxiosError: typeof axios.isAxiosError }).isAxiosError =
-        jest.fn(() => true) as unknown as typeof axios.isAxiosError;
-
-      mockAxiosInstance.get.mockRejectedValueOnce(axiosErr);
-
-      await expect(fetcher.fetchSpec()).rejects.toThrow('Endpoint not found');
-    });
-  });
-});
-
-describe('SwaggerFetcher auxiliary methods', () => {
-  let fetcher: SwaggerFetcher;
-  type MockAxiosInstance = {
-    get: jest.Mock;
-    post: jest.Mock;
-    defaults: Record<string, unknown>;
-  };
-  let mockAxiosInstance: MockAxiosInstance;
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.clearAllMocks();
-
-    mockAxiosInstance = {
-      get: jest.fn(),
-      post: jest.fn(),
-      defaults: {},
-    };
-
-    const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
-    mockedAxios.create = jest.fn().mockReturnValue(mockAxiosInstance);
-    (mockedAxios as unknown as { isAxiosError: typeof axios.isAxiosError }).isAxiosError = jest.fn(
-      () => false
-    ) as unknown as typeof axios.isAxiosError;
-
-    fetcher = new SwaggerFetcher({ baseUrl: 'https://teamcity.example.com', token: 't' });
-  });
-
-  it('testConnection returns true on 200, false on error', async () => {
-    mockAxiosInstance.get.mockResolvedValueOnce({ status: 200, data: { version: '1' } });
-    await expect(fetcher.testConnection()).resolves.toBe(true);
-
-    mockAxiosInstance.get.mockRejectedValueOnce(new Error('boom'));
-    await expect(fetcher.testConnection()).resolves.toBe(false);
-  });
-
-  it('getServerVersion returns version or null on error', async () => {
-    mockAxiosInstance.get.mockResolvedValueOnce({ status: 200, data: { version: '2024.1' } });
-    await expect(fetcher.getServerVersion()).resolves.toBe('2024.1');
-
-    mockAxiosInstance.get.mockRejectedValueOnce(new Error('boom'));
-    await expect(fetcher.getServerVersion()).resolves.toBeNull();
-  });
-});
-
-describe('SwaggerValidator', () => {
-  let validator: SwaggerValidator;
-
-  beforeEach(() => {
-    validator = new SwaggerValidator();
-  });
-
-  describe('validateSpec', () => {
-    it('should validate Swagger 2.0 specification', () => {
-      const spec = {
-        swagger: '2.0',
-        info: {
-          version: '1.0.0',
-          title: 'API',
-        },
-        paths: {},
-      };
-
-      const result = validator.validateSpec(spec);
-      expect(result.isValid).toBe(true);
-      expect(result.version).toBe('2.0');
-    });
-
-    it('should validate OpenAPI 3.0 specification', () => {
-      const spec = {
-        openapi: '3.0.0',
-        info: {
-          version: '1.0.0',
-          title: 'API',
-        },
-        paths: {},
-      };
-
-      const result = validator.validateSpec(spec);
-      expect(result.isValid).toBe(true);
-      expect(result.version).toBe('3.0.0');
-    });
-
-    it('should reject invalid specification', () => {
-      const spec = {
-        notValid: true,
-      };
-
-      const result = validator.validateSpec(spec);
-      expect(result.isValid).toBe(false);
-      expect(result.errors).toBeDefined();
-      expect(result.errors).toContain('Invalid specification format');
-    });
-
-    it('should detect TeamCity version from spec', () => {
-      const spec = {
-        swagger: '2.0',
-        info: {
-          version: '2023.11.1 (build 147412)',
-          title: 'TeamCity REST API',
-        },
-        paths: {},
-      };
-
-      const result = validator.validateSpec(spec);
-      expect(result.isValid).toBe(true);
-      expect(result.teamCityVersion).toBe('2023.11.1');
-    });
-
-    it('should provide warnings for deprecated features', () => {
-      const spec = {
-        swagger: '2.0',
-        info: {
-          version: '1.0.0',
-          title: 'API',
-        },
-        paths: {},
-        // Mock deprecated feature
-        definitions: {
-          DeprecatedModel: {
-            deprecated: true,
-            type: 'object',
-          },
-        },
-      };
-
-      const result = validator.validateSpec(spec);
-      expect(result.isValid).toBe(true);
-      // In a real implementation, this would check for deprecated warnings
-    });
-  });
-
-  describe('isVersionSupported', () => {
-    it('should accept supported TeamCity versions', () => {
-      const validator = new SwaggerValidator();
-      expect(validator.isVersionSupported('2023.11')).toBe(true);
-      expect(validator.isVersionSupported('2024.01')).toBe(true);
-      expect(validator.isVersionSupported('2022.10')).toBe(true);
-    });
-
-    it('should reject unsupported TeamCity versions', () => {
-      const validator = new SwaggerValidator();
-      expect(validator.isVersionSupported('2019.2')).toBe(false);
-      expect(validator.isVersionSupported('2018.1')).toBe(false);
-    });
-  });
-});
-
-describe('SwaggerCache', () => {
-  let cache: SwaggerCache;
-  let mockFs: jest.Mocked<typeof fsPromises>;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockFs = fsPromises as unknown as jest.Mocked<typeof fsPromises>;
-
-    // Spy on fs methods and provide defaults
-    // Configure default mocks for fs/promises
-    mockFs.readFile.mockReset();
-    mockFs.writeFile.mockReset();
-    mockFs.access.mockReset();
-    mockFs.readdir.mockReset();
-    mockFs.unlink.mockReset();
-    mockFs.rm.mockReset();
-    mockFs.stat.mockReset();
-
-    mockFs.writeFile.mockResolvedValue(undefined as unknown as void);
-    mockFs.readdir.mockResolvedValue([] as unknown as ReturnType<typeof fsPromises.readdir>);
-    mockFs.unlink.mockResolvedValue(undefined as unknown as void);
-    mockFs.rm.mockResolvedValue(undefined as unknown as void);
-
-    cache = new SwaggerCache({
-      cacheDir: '/tmp/teamcity-cache',
-      ttl: 24 * 60 * 60 * 1000, // 24 hours
-    });
-  });
-
-  afterEach(() => {
-    // Restore original fs/promises methods so subsequent tests can spy again
-    jest.restoreAllMocks();
-  });
-
-  describe('get', () => {
-    it('should return cached spec if valid', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      const cachedData = {
-        spec: mockSpec,
-        timestamp: Date.now() - 1000, // 1 second ago
-        hash: 'abc123',
-      };
-
-      mockFs.readFile.mockResolvedValueOnce(JSON.stringify(cachedData));
-
-      const result = await cache.get('test-key');
-      expect(result).toEqual(mockSpec);
-    });
-
-    it('should return null if cache expired', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      const cachedData = {
-        spec: mockSpec,
-        timestamp: Date.now() - 25 * 60 * 60 * 1000, // 25 hours ago
-        hash: 'abc123',
-      };
-
-      mockFs.readFile.mockResolvedValueOnce(JSON.stringify(cachedData));
-
-      const result = await cache.get('test-key');
-      expect(result).toBeNull();
-    });
-
-    it('should handle cache age calculation correctly', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      // Test cache that's just under the TTL limit (should still be valid)
-      const almostExpiredData = {
-        spec: mockSpec,
-        timestamp: Date.now() - 23 * 60 * 60 * 1000, // 23 hours ago (TTL is 24h)
-        hash: 'abc123',
-      };
-
-      mockFs.readFile.mockResolvedValueOnce(JSON.stringify(almostExpiredData));
-
-      const result = await cache.get('test-key-valid');
-      expect(result).toEqual(mockSpec);
-
-      // Test cache that's just over the TTL limit (should be expired)
-      const expiredData = {
-        spec: mockSpec,
-        timestamp: Date.now() - 25 * 60 * 60 * 1000, // 25 hours ago
-        hash: 'abc123',
-      };
-
-      mockFs.readFile.mockResolvedValueOnce(JSON.stringify(expiredData));
-
-      const expiredResult = await cache.get('test-key-expired');
-      expect(expiredResult).toBeNull();
-    });
-
-    it('should return null if cache file not found', async () => {
-      mockFs.readFile.mockRejectedValueOnce(new Error('ENOENT'));
-
-      const result = await cache.get('test-key');
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('set', () => {
-    it('should save spec to cache with timestamp', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      await cache.set('test-key', mockSpec);
-
-      // Verify that writeFile was called with the correct parameters
-      expect(mockFs.writeFile).toHaveBeenCalledWith(
-        expect.stringContaining('test-key.json'),
-        expect.any(String),
-        'utf-8'
-      );
-
-      // Verify the written JSON content structure
-      const writeCallArgs = (mockFs.writeFile as jest.Mock).mock.calls[0];
-      const writtenJson = writeCallArgs[1];
-      const parsedData = JSON.parse(writtenJson);
-
-      expect(parsedData).toHaveProperty('spec', mockSpec);
-      expect(parsedData).toHaveProperty('timestamp');
-      expect(parsedData).toHaveProperty('hash');
-      expect(typeof parsedData.timestamp).toBe('number');
-      expect(typeof parsedData.hash).toBe('string');
-      expect(parsedData.hash).toHaveLength(8); // Hash should be 8 characters
-    });
-
-    it('should save cache with current timestamp', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      const beforeTimestamp = Date.now();
-      await cache.set('timestamp-test', mockSpec);
-      const afterTimestamp = Date.now();
-
-      const writeCallArgs = (mockFs.writeFile as jest.Mock).mock.calls[0];
-      const parsedData = JSON.parse(writeCallArgs[1]);
-
-      // Timestamp should be between before and after the call
-      expect(parsedData.timestamp).toBeGreaterThanOrEqual(beforeTimestamp);
-      expect(parsedData.timestamp).toBeLessThanOrEqual(afterTimestamp);
-    });
-
-    it('should generate consistent hash for same spec', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      await cache.set('hash-test-1', mockSpec);
-      await cache.set('hash-test-2', mockSpec);
-
-      const calls = (mockFs.writeFile as jest.Mock).mock.calls;
-      const data1 = JSON.parse(calls[0][1]);
-      const data2 = JSON.parse(calls[1][1]);
-
-      // Same spec should generate same hash
-      expect(data1.hash).toBe(data2.hash);
-      expect(data1.hash).toHaveLength(8);
-    });
-
-    it('should generate different hash for different specs', async () => {
-      const mockSpec1 = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      const mockSpec2 = {
-        swagger: '2.0',
-        info: { version: '2.0.0', title: 'Different API' },
-        paths: { '/test': {} },
-      };
-
-      await cache.set('diff-test-1', mockSpec1);
-      await cache.set('diff-test-2', mockSpec2);
-
-      const calls = (mockFs.writeFile as jest.Mock).mock.calls;
-      const data1 = JSON.parse(calls[0][1]);
-      const data2 = JSON.parse(calls[1][1]);
-
-      // Different specs should generate different hashes
-      expect(data1.hash).not.toBe(data2.hash);
-      expect(data1.hash).toHaveLength(8);
-      expect(data2.hash).toHaveLength(8);
-    });
-
-    it('should create cache directory if it does not exist', async () => {
-      const mockSpec = {
-        swagger: '2.0',
-        info: { version: '1.0.0', title: 'API' },
-        paths: {},
-      };
-
-      mockFs.access.mockRejectedValueOnce(new Error('ENOENT'));
-
-      await cache.set('test-key', mockSpec);
-
-      // Verify that the cache was written under the expected directory
-      const writePath = (mockFs.writeFile as jest.Mock).mock.calls[0][0];
-      expect(writePath).toContain('/tmp/teamcity-cache/');
-    });
-  });
-
-  describe('clear', () => {
-    it('should remove all cache files', async () => {
-      mockFs.readdir.mockResolvedValueOnce([
-        'file1.json',
-        'file2.json',
-        'other.txt',
-      ] as unknown as ReturnType<typeof fsPromises.readdir>);
-
-      await cache.clear();
-
-      expect(mockFs.unlink).toHaveBeenCalledWith(expect.stringContaining('file1.json'));
-      expect(mockFs.unlink).toHaveBeenCalledWith(expect.stringContaining('file2.json'));
-      expect(mockFs.unlink).not.toHaveBeenCalledWith(expect.stringContaining('other.txt'));
-    });
-
-    it('should handle clear when cache directory does not exist', async () => {
-      mockFs.readdir.mockRejectedValueOnce(new Error('ENOENT'));
-
-      await expect(cache.clear()).resolves.not.toThrow();
-    });
-  });
-
-  // describe('has', () => {
-  //   it('should return true if valid cache exists', async () => {
-  //     const cachedData = {
-  //       spec: { swagger: '2.0' },
-  //       timestamp: Date.now() - 1000,
-  //       hash: 'abc123',
-  //     };
-
-  //     mockFs.readFile.mockResolvedValueOnce(JSON.stringify(cachedData));
-
-  //     const result = await cache.has('test-key');
-  //     expect(result).toBe(true);
-  //   });
-
-  //   it('should return false if cache expired', async () => {
-  //     const cachedData = {
-  //       spec: { swagger: '2.0' },
-  //       timestamp: Date.now() - (25 * 60 * 60 * 1000),
-  //       hash: 'abc123',
-  //     };
-
-  //     mockFs.readFile.mockResolvedValueOnce(JSON.stringify(cachedData));
-
-  //     const result = await cache.has('test-key');
-  //     expect(result).toBe(false);
-  //   });
-
-  //   it('should return false if cache does not exist', async () => {
-  //     mockFs.readFile.mockRejectedValueOnce(new Error('ENOENT'));
-
-  //     const result = await cache.has('test-key');
-  //     expect(result).toBe(false);
-  //   });
-  // });
-
-  describe('getStats', () => {
-    it('should return cache statistics', async () => {
-      mockFs.readdir.mockResolvedValueOnce(['file1.json', 'file2.json'] as unknown as ReturnType<
-        typeof fsPromises.readdir
-      >);
-      mockFs.stat.mockResolvedValue({
-        size: 1000,
-        mtime: new Date(),
-      } as unknown as Stats);
-
-      const stats = await cache.getStats();
-
-      expect(stats).toHaveProperty('size');
-      expect(stats).toHaveProperty('files', 2);
-      expect(stats).toHaveProperty('oldestFile');
-      expect(stats).toHaveProperty('newestFile');
-    });
-
-    it('should handle empty cache', async () => {
-      mockFs.readdir.mockResolvedValueOnce([]);
-
-      const stats = await cache.getStats();
-
-      expect(stats).toEqual({
-        size: 0,
-        files: 0,
-      });
-    });
-  });
-});