@dpesch/mantisbt-mcp-server 1.10.3 → 1.10.6

package/tests/cache.test.ts

@@ -1,265 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// vi.mock must be at module top level — vitest hoists it automatically
-vi.mock('node:fs/promises');
-
-import { readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
-import { MetadataCache, type CachedMetadata } from '../src/cache.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const CACHE_DIR = '/tmp/test-cache';
-const TTL = 3600; // 1 hour in seconds
-
-function makeCache(): MetadataCache {
-  return new MetadataCache(CACHE_DIR, TTL);
-}
-
-function makeSampleMetadata(): CachedMetadata {
-  return {
-    timestamp: Date.now(),
-    projects: [{ id: 1, name: 'Test Project' }],
-    byProject: {},
-    tags: [],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// isValid()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – isValid()', () => {
-  it('returns false when file does not exist (readFile throws)', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(false);
-  });
-
-  it('returns true when file is fresh (within TTL)', async () => {
-    const file = { timestamp: Date.now(), data: makeSampleMetadata() };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(true);
-  });
-
-  it('returns false when file has expired (timestamp older than TTL)', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const file = { timestamp: expiredTimestamp, data: makeSampleMetadata() };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// load()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – load()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.load()).resolves.toBeNull();
-  });
-
-  it('returns CachedMetadata when file exists', async () => {
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: Date.now(), data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.load();
-    expect(result).toEqual(metadata);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// save()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – save()', () => {
-  it('calls mkdir with recursive:true and writeFile with JSON content', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const metadata = makeSampleMetadata();
-    await cache.save(metadata);
-
-    expect(mkdir).toHaveBeenCalledWith(CACHE_DIR, { recursive: true });
-    expect(writeFile).toHaveBeenCalledOnce();
-
-    // Verify the written JSON contains our data
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number; data: CachedMetadata };
-    expect(parsed.data).toEqual(metadata);
-  });
-
-  it('writes a timestamp to the cache file', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const before = Date.now();
-    const cache = makeCache();
-    await cache.save(makeSampleMetadata());
-    const after = Date.now();
-
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number };
-    expect(parsed.timestamp).toBeGreaterThanOrEqual(before);
-    expect(parsed.timestamp).toBeLessThanOrEqual(after);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// invalidate()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – invalidate()', () => {
-  it('calls unlink on the cache file', async () => {
-    vi.mocked(unlink).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    await cache.invalidate();
-
-    expect(unlink).toHaveBeenCalledOnce();
-    const calledPath = vi.mocked(unlink).mock.calls[0][0] as string;
-    expect(calledPath).toContain('metadata.json');
-  });
-
-  it('does not throw when file does not exist (unlink rejects)', async () => {
-    vi.mocked(unlink).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.invalidate()).resolves.toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// loadIfValid()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – loadIfValid()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.loadIfValid()).resolves.toBeNull();
-  });
-
-  it('returns data when file is fresh (within TTL)', async () => {
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: Date.now(), data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.loadIfValid();
-    expect(result).toEqual(metadata);
-  });
-
-  it('returns null when file has expired', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: expiredTimestamp, data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.loadIfValid()).resolves.toBeNull();
-  });
-
-  it('reads from metadata.json path', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await cache.loadIfValid();
-
-    expect(readFile).toHaveBeenCalledOnce();
-    const calledPath = vi.mocked(readFile).mock.calls[0][0] as string;
-    expect(calledPath).toContain('metadata.json');
-    expect(calledPath).not.toContain('issue_fields.json');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// loadIssueFields()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – loadIssueFields()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.loadIssueFields()).resolves.toBeNull();
-  });
-
-  it('returns fields array when file is fresh', async () => {
-    const fields = ['id', 'summary', 'status'];
-    const file = { timestamp: Date.now(), fields };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.loadIssueFields();
-    expect(result).toEqual(fields);
-  });
-
-  it('returns null when file has expired', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const file = { timestamp: expiredTimestamp, fields: ['id', 'summary'] };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.loadIssueFields()).resolves.toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// saveIssueFields()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – saveIssueFields()', () => {
-  it('calls mkdir with recursive:true and writes to issue_fields.json', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const fields = ['id', 'summary', 'status', 'priority'];
-    await cache.saveIssueFields(fields);
-
-    expect(mkdir).toHaveBeenCalledWith(CACHE_DIR, { recursive: true });
-    expect(writeFile).toHaveBeenCalledOnce();
-
-    const calledPath = vi.mocked(writeFile).mock.calls[0][0] as string;
-    expect(calledPath).toContain('issue_fields.json');
-  });
-
-  it('written JSON contains the fields array and a timestamp', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const fields = ['id', 'summary', 'status'];
-    const before = Date.now();
-    await cache.saveIssueFields(fields);
-    const after = Date.now();
-
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number; fields: string[] };
-    expect(parsed.fields).toEqual(fields);
-    expect(parsed.timestamp).toBeGreaterThanOrEqual(before);
-    expect(parsed.timestamp).toBeLessThanOrEqual(after);
-  });
-});

package/tests/client.test.ts

@@ -1,372 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MantisClient, MantisApiError, buildIssueViewUrl, buildNoteViewUrl } from '../src/client.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeResponse(
-  status: number,
-  body: string,
-  headers: Record<string, string> = {},
-): Response {
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    statusText: `Status ${status}`,
-    text: () => Promise.resolve(body),
-    headers: {
-      get: (key: string) => headers[key] ?? null,
-    },
-  } as unknown as Response;
-}
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.unstubAllGlobals();
-});
-
-// ---------------------------------------------------------------------------
-// URL building
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – URL building', () => {
-  it('appends /api/rest/<path> to the base URL', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token123');
-    return client.get('issues/42').then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      expect(calledUrl).toBe('https://mantis.example.com/api/rest/issues/42');
-    });
-  });
-
-  it('strips trailing slash from base URL', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com/', 'token123');
-    return client.get('issues').then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      expect(calledUrl).toBe('https://mantis.example.com/api/rest/issues');
-    });
-  });
-
-  it('strips /api/rest suffix when user includes it in the base URL', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com/api/rest', 'token123');
-    return client.get('issues/42').then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      expect(calledUrl).toBe('https://mantis.example.com/api/rest/issues/42');
-    });
-  });
-
-  it('strips /api/rest/ (with trailing slash) from base URL', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com/api/rest/', 'token123');
-    return client.get('issues/42').then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      expect(calledUrl).toBe('https://mantis.example.com/api/rest/issues/42');
-    });
-  });
-
-  it('appends defined query parameters', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token123');
-    return client.get('issues', { page_size: 10, page: 1 }).then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      const url = new URL(calledUrl);
-      expect(url.searchParams.get('page_size')).toBe('10');
-      expect(url.searchParams.get('page')).toBe('1');
-    });
-  });
-
-  it('omits undefined query parameters', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token123');
-    return client.get('issues', { page_size: 10, filter_id: undefined }).then(() => {
-      const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-      const url = new URL(calledUrl);
-      expect(url.searchParams.has('filter_id')).toBe(false);
-      expect(url.searchParams.get('page_size')).toBe('10');
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Request headers
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – request headers', () => {
-  it('sends Authorization and Content-Type headers', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'myApiKey');
-    return client.get('issues').then(() => {
-      const options = fetchMock.mock.calls[0][1] as RequestInit;
-      const headers = options.headers as Record<string, string>;
-      expect(headers['Authorization']).toBe('myApiKey');
-      expect(headers['Content-Type']).toBe('application/json');
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// handleResponse
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – handleResponse', () => {
-  it('returns parsed JSON on 200', () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(200, JSON.stringify({ id: 42 })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    return client.get<{ id: number }>('issues/42').then((result) => {
-      expect(result).toEqual({ id: 42 });
-    });
-  });
-
-  it('returns undefined on 204 No Content', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(204, ''));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    return client.delete('issues/42').then((result) => {
-      expect(result).toBeUndefined();
-    });
-  });
-
-  it('throws MantisApiError with statusCode on 4xx', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(404, JSON.stringify({ message: 'Issue not found' })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    await expect(client.get('issues/9999')).rejects.toMatchObject({
-      statusCode: 404,
-      name: 'MantisApiError',
-    });
-  });
-
-  it('uses raw body as message when JSON has no message field', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(403, JSON.stringify({ detail: 'forbidden' })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    // When body is JSON but has no `message` key, the raw body string is used
-    await expect(client.get('issues')).rejects.toThrow('{"detail":"forbidden"}');
-  });
-
-  it('MantisApiError is instanceof Error', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(401, JSON.stringify({ message: 'Unauthorized' })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    await expect(client.get('issues')).rejects.toBeInstanceOf(MantisApiError);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HTTP methods
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – HTTP methods', () => {
-  it('sends POST with JSON body', () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(201, JSON.stringify({ id: 1 })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    const payload = { summary: 'New issue', project: { id: 1 } };
-    return client.post('issues', payload).then(() => {
-      const options = fetchMock.mock.calls[0][1] as RequestInit;
-      expect(options.method).toBe('POST');
-      expect(options.body).toBe(JSON.stringify(payload));
-    });
-  });
-
-  it('sends PATCH request', () => {
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(200, JSON.stringify({ id: 1 })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    return client.patch('issues/1', { summary: 'Updated' }).then(() => {
-      const options = fetchMock.mock.calls[0][1] as RequestInit;
-      expect(options.method).toBe('PATCH');
-    });
-  });
-
-  it('sends DELETE request', () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(204, ''));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    return client.delete('issues/1').then(() => {
-      const options = fetchMock.mock.calls[0][1] as RequestInit;
-      expect(options.method).toBe('DELETE');
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Credential factory (lazy constructor)
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – credential factory', () => {
-  it('does not call the factory until the first API method', async () => {
-    const factory = vi.fn().mockResolvedValue({
-      baseUrl: 'https://lazy.example.com',
-      apiKey: 'lazy-key',
-    });
-
-    new MantisClient(factory);
-
-    expect(factory).not.toHaveBeenCalled();
-  });
-
-  it('calls the factory on first API method and uses the returned credentials', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const factory = vi.fn().mockResolvedValue({
-      baseUrl: 'https://lazy.example.com',
-      apiKey: 'lazy-key',
-    });
-
-    const client = new MantisClient(factory);
-    await client.get('issues');
-
-    expect(factory).toHaveBeenCalledOnce();
-    const calledUrl: string = fetchMock.mock.calls[0][0] as string;
-    expect(calledUrl).toBe('https://lazy.example.com/api/rest/issues');
-    const options = fetchMock.mock.calls[0][1] as RequestInit;
-    expect((options.headers as Record<string, string>)['Authorization']).toBe('lazy-key');
-  });
-
-  it('caches credentials after the first call and does not call the factory again', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(makeResponse(200, '{}'));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const factory = vi.fn().mockResolvedValue({
-      baseUrl: 'https://lazy.example.com',
-      apiKey: 'lazy-key',
-    });
-
-    const client = new MantisClient(factory);
-    await client.get('issues');
-    await client.get('projects');
-
-    expect(factory).toHaveBeenCalledOnce();
-  });
-
-  it('forwards the responseObserver when using factory constructor', async () => {
-    const observer = vi.fn();
-    const fakeResponse = makeResponse(200, '{}');
-    const fetchMock = vi.fn().mockResolvedValue(fakeResponse);
-    vi.stubGlobal('fetch', fetchMock);
-
-    const factory = vi.fn().mockResolvedValue({
-      baseUrl: 'https://lazy.example.com',
-      apiKey: 'lazy-key',
-    });
-
-    const client = new MantisClient(factory, observer);
-    await client.get('issues');
-
-    expect(observer).toHaveBeenCalledOnce();
-    expect(observer).toHaveBeenCalledWith(fakeResponse);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// responseObserver
-// ---------------------------------------------------------------------------
-
-describe('MantisClient – responseObserver', () => {
-  it('calls responseObserver on successful response', () => {
-    const observer = vi.fn();
-    const fakeResponse = makeResponse(200, '{}');
-    const fetchMock = vi.fn().mockResolvedValue(fakeResponse);
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token', observer);
-    return client.get('issues').then(() => {
-      expect(observer).toHaveBeenCalledOnce();
-      expect(observer).toHaveBeenCalledWith(fakeResponse);
-    });
-  });
-
-  it('does not call responseObserver on error response', async () => {
-    const observer = vi.fn();
-    const fetchMock = vi.fn().mockResolvedValue(
-      makeResponse(500, JSON.stringify({ message: 'Internal Server Error' })),
-    );
-    vi.stubGlobal('fetch', fetchMock);
-
-    const client = new MantisClient('https://mantis.example.com', 'token', observer);
-    await expect(client.get('issues')).rejects.toBeInstanceOf(MantisApiError);
-    expect(observer).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// URL helpers
-// ---------------------------------------------------------------------------
-
-describe('buildIssueViewUrl', () => {
-  it('builds the correct MantisBT issue view URL', () => {
-    expect(buildIssueViewUrl('https://mantis.example.com', 42))
-      .toBe('https://mantis.example.com/view.php?id=42');
-  });
-
-  it('works with base URLs that have a path prefix', () => {
-    expect(buildIssueViewUrl('https://example.com/mantis', 1))
-      .toBe('https://example.com/mantis/view.php?id=1');
-  });
-});
-
-describe('buildNoteViewUrl', () => {
-  it('builds the correct MantisBT note anchor URL', () => {
-    expect(buildNoteViewUrl('https://mantis.example.com', 42, 99))
-      .toBe('https://mantis.example.com/view.php?id=42#bugnote99');
-  });
-});
-
-describe('MantisClient – getBaseUrl', () => {
-  it('returns the normalized base URL (direct constructor)', async () => {
-    const client = new MantisClient('https://mantis.example.com', 'token');
-    expect(await client.getBaseUrl()).toBe('https://mantis.example.com');
-  });
-
-  it('returns the base URL from the credential factory', async () => {
-    const factory = vi.fn().mockResolvedValue({
-      baseUrl: 'https://lazy.example.com',
-      apiKey: 'key',
-    });
-    const client = new MantisClient(factory);
-    expect(await client.getBaseUrl()).toBe('https://lazy.example.com');
-  });
-});