@dpesch/mantisbt-mcp-server 1.10.2 → 1.10.6

package/tests/resources/resources.test.ts

@@ -1,309 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { MantisClient } from '../../src/client.js';
-import { MetadataCache } from '../../src/cache.js';
-import { registerResources } from '../../src/resources/index.js';
-import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
-
-// ---------------------------------------------------------------------------
-// Inline fixtures
-// ---------------------------------------------------------------------------
-
-const USER_FIXTURE = { id: 1, name: 'jsmith', real_name: 'John Smith', email: 'jsmith@example.com' };
-
-const PROJECTS_FIXTURE = [
-  { id: 10, name: 'Alpha', enabled: true },
-  { id: 11, name: 'Beta',  enabled: true },
-];
-
-// Simulates a raw MantisBT API response with extra fields that must be stripped
-const PROJECTS_RAW_FIXTURE = [
-  {
-    id: 10,
-    name: 'Alpha',
-    enabled: true,
-    status: { id: 10, name: 'development', label: 'Entwicklung' },
-    view_state: { id: 10, name: 'public', label: 'Öffentlich' },
-    custom_fields: [
-      { id: 1, name: 'Reklamieren', type: 'checkbox', default_value: '', possible_values: 'Ja' },
-    ],
-  },
-];
-
-const ENUM_FIXTURE = {
-  configs: [
-    { option: 'severity_enum_string',        value: '10:feature,50:minor,80:block' },
-    { option: 'status_enum_string',          value: '10:new,80:resolved,90:closed' },
-    { option: 'priority_enum_string',        value: '10:none,30:normal,60:immediate' },
-    { option: 'resolution_enum_string',      value: '10:open,20:fixed' },
-    { option: 'reproducibility_enum_string', value: '10:always,70:have not tried' },
-  ],
-};
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-let mockServer: MockMcpServer;
-let client: MantisClient;
-let cache: MetadataCache;
-
-beforeEach(() => {
-  mockServer = new MockMcpServer();
-  client = new MantisClient('https://mantis.example.com', 'test-token');
-  cache = new MetadataCache('/tmp/cache-resources-test', 86400);
-  registerResources(mockServer as never, client, cache);
-  vi.stubGlobal('fetch', vi.fn());
-});
-
-afterEach(async () => {
-  vi.unstubAllGlobals();
-  await cache.invalidate();
-});
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-describe('resource registration', () => {
-  it('registers mantis://me', () => {
-    expect(mockServer.hasResourceRegistered('mantis://me')).toBe(true);
-  });
-
-  it('registers mantis://projects', () => {
-    expect(mockServer.hasResourceRegistered('mantis://projects')).toBe(true);
-  });
-
-  it('registers mantis://enums', () => {
-    expect(mockServer.hasResourceRegistered('mantis://enums')).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// mantis://me
-// ---------------------------------------------------------------------------
-
-describe('mantis://me', () => {
-  it('returns a single content item with application/json', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://me');
-
-    expect(result.contents).toHaveLength(1);
-    expect(result.contents[0]!.mimeType).toBe('application/json');
-  });
-
-  it('sets uri to mantis://me', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://me');
-
-    expect(result.contents[0]!.uri).toBe('mantis://me');
-  });
-
-  it('returns valid JSON with id and name', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://me');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as { id: number; name: string };
-    expect(parsed.id).toBe(USER_FIXTURE.id);
-    expect(parsed.name).toBe(USER_FIXTURE.name);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// mantis://projects
-// ---------------------------------------------------------------------------
-
-describe('mantis://projects', () => {
-  it('returns a single content item with application/json', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    expect(result.contents).toHaveLength(1);
-    expect(result.contents[0]!.mimeType).toBe('application/json');
-  });
-
-  it('sets uri to mantis://projects', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    expect(result.contents[0]!.uri).toBe('mantis://projects');
-  });
-
-  it('returns a JSON array of projects from live API when cache is empty', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as unknown[];
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed).toHaveLength(2);
-  });
-
-  it('returns minified JSON (no indentation)', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    expect(result.contents[0]!.text).not.toContain('\n');
-  });
-
-  it('strips custom_fields from live API response', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_RAW_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Array<Record<string, unknown>>;
-    expect(parsed[0]).not.toHaveProperty('custom_fields');
-  });
-
-  it('preserves label on status and view_state from live API response', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_RAW_FIXTURE })));
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Array<Record<string, unknown>>;
-    expect((parsed[0]!['status'] as Record<string, unknown>)['label']).toBe('Entwicklung');
-    expect((parsed[0]!['view_state'] as Record<string, unknown>)['label']).toBe('Öffentlich');
-  });
-
-  it('serves from cache without calling the API when cache is valid', async () => {
-    await cache.save({
-      timestamp: Date.now(),
-      projects: PROJECTS_FIXTURE,
-      byProject: {},
-      tags: [],
-    });
-
-    const result = await mockServer.callResource('mantis://projects');
-
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-    const parsed = JSON.parse(result.contents[0]!.text) as unknown[];
-    expect(parsed).toHaveLength(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// mantis://projects/{id}
-// ---------------------------------------------------------------------------
-
-describe('mantis://projects/{id}', () => {
-  it('registers the template resource', () => {
-    expect(mockServer.hasResourceRegistered('mantis://projects/{id}')).toBe(true);
-  });
-
-  it('returns combined project view from cache (users, versions, categories)', async () => {
-    const projectsFixture = [{ id: 10, name: 'Alpha', enabled: true }];
-    await cache.save({
-      timestamp: Date.now(),
-      projects: projectsFixture,
-      byProject: {
-        10: {
-          users: [{ id: 1, name: 'jsmith' }],
-          versions: [{ id: 5, name: '1.0.0', released: true }],
-          categories: [{ id: 3, name: 'Bugs' }],
-        },
-      },
-      tags: [],
-    });
-
-    const result = await mockServer.callResource('mantis://projects/10');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, unknown>;
-    expect(parsed['id']).toBe(10);
-    expect(parsed['name']).toBe('Alpha');
-    expect(parsed['users']).toHaveLength(1);
-    expect(parsed['versions']).toHaveLength(1);
-    expect(parsed['categories']).toHaveLength(1);
-    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('fetches live data in parallel when cache is cold', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ projects: [{ id: 10, name: 'Alpha', categories: [{ id: 3, name: 'Bugs' }] }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [{ id: 1, name: 'jsmith' }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ versions: [{ id: 5, name: '1.0.0' }] })));
-
-    const result = await mockServer.callResource('mantis://projects/10');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, unknown>;
-    expect(parsed['id']).toBe(10);
-    expect((parsed['users'] as unknown[]).length).toBeGreaterThan(0);
-    expect((parsed['versions'] as unknown[]).length).toBeGreaterThan(0);
-    expect((parsed['categories'] as unknown[]).length).toBeGreaterThan(0);
-  });
-
-  it('strips [All Projects] prefix from category names on live fetch', async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ projects: [{ id: 10, name: 'Alpha', categories: [{ id: 1, name: '[All Projects] General' }] }] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [] })))
-      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ versions: [] })));
-
-    const result = await mockServer.callResource('mantis://projects/10');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as { categories: Array<{ name: string }> };
-    expect(parsed.categories[0]!.name).toBe('General');
-  });
-
-  it('returns minified JSON', async () => {
-    await cache.save({
-      timestamp: Date.now(),
-      projects: [{ id: 10, name: 'Alpha' }],
-      byProject: { 10: { users: [], versions: [], categories: [] } },
-      tags: [],
-    });
-
-    const result = await mockServer.callResource('mantis://projects/10');
-
-    expect(result.contents[0]!.text).not.toContain('\n');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// mantis://enums
-// ---------------------------------------------------------------------------
-
-describe('mantis://enums', () => {
-  it('returns a single content item with application/json', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://enums');
-
-    expect(result.contents).toHaveLength(1);
-    expect(result.contents[0]!.mimeType).toBe('application/json');
-  });
-
-  it('sets uri to mantis://enums', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://enums');
-
-    expect(result.contents[0]!.uri).toBe('mantis://enums');
-  });
-
-  it('returns parsed enum groups with id and name entries', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://enums');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, Array<{ id: number; name: string }>>;
-    for (const key of ['severity', 'priority', 'status', 'resolution', 'reproducibility']) {
-      expect(Array.isArray(parsed[key])).toBe(true);
-      expect(parsed[key]!.length).toBeGreaterThan(0);
-      expect(parsed[key]![0]).toMatchObject({ id: expect.any(Number), name: expect.any(String) });
-    }
-  });
-
-  it('parses severity values correctly from fixture', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
-
-    const result = await mockServer.callResource('mantis://enums');
-
-    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, Array<{ id: number; name: string }>>;
-    expect(parsed['severity']).toContainEqual({ id: 10, name: 'feature' });
-    expect(parsed['severity']).toContainEqual({ id: 50, name: 'minor' });
-  });
-});

package/tests/search/embedder.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Embedder } from '../../src/search/embedder.js';
-
-// ---------------------------------------------------------------------------
-// Mock @huggingface/transformers (dynamic import)
-// ---------------------------------------------------------------------------
-
-const mockPipelineFn = vi.fn(async (texts: string | string[]) => {
-  if (Array.isArray(texts)) {
-    return texts.map(() => ({ data: new Float32Array(4).fill(0.1), dims: [1, 4] }));
-  }
-  return { data: new Float32Array(4).fill(0.1), dims: [4] };
-});
-
-const mockPipelineFactory = vi.fn(async (_task: string, _model: string, _opts?: unknown) => mockPipelineFn);
-
-vi.mock('@huggingface/transformers', () => ({
-  pipeline: mockPipelineFactory,
-}));
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// Thread configuration
-// ---------------------------------------------------------------------------
-
-describe('Embedder – thread configuration', () => {
-  it('passes intra_op_num_threads=1 by default', async () => {
-    const embedder = new Embedder('test-model');
-    await embedder.embed('hello');
-
-    expect(mockPipelineFactory).toHaveBeenCalledWith(
-      'feature-extraction',
-      'test-model',
-      expect.objectContaining({
-        session_options: { intra_op_num_threads: 1, inter_op_num_threads: 1 },
-      }),
-    );
-  });
-
-  it('passes configured numThreads to intra_op_num_threads; inter stays 1', async () => {
-    const embedder = new Embedder('test-model', 4);
-    await embedder.embed('hello');
-
-    expect(mockPipelineFactory).toHaveBeenCalledWith(
-      'feature-extraction',
-      'test-model',
-      expect.objectContaining({
-        session_options: { intra_op_num_threads: 4, inter_op_num_threads: 1 },
-      }),
-    );
-  });
-
-  it('loads the pipeline only once (lazy singleton)', async () => {
-    const embedder = new Embedder('test-model', 1);
-    await embedder.embed('first');
-    await embedder.embed('second');
-
-    expect(mockPipelineFactory).toHaveBeenCalledTimes(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Embedder default — numThreads omitted
-// ---------------------------------------------------------------------------
-
-describe('Embedder – numThreads default', () => {
-  it('uses intra_op_num_threads=1 when numThreads is not passed', async () => {
-    const embedder = new Embedder('m');
-    await embedder.embed('x');
-    expect(mockPipelineFactory).toHaveBeenCalledWith(
-      'feature-extraction',
-      'm',
-      expect.objectContaining({
-        session_options: expect.objectContaining({ intra_op_num_threads: 1 }),
-      }),
-    );
-  });
-});

package/tests/search/highlight.test.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractTerms, highlightText, extractSnippet } from '../../src/search/highlight.js';
-
-// ---------------------------------------------------------------------------
-// extractTerms
-// ---------------------------------------------------------------------------
-
-describe('extractTerms', () => {
-  it('splits by whitespace and returns terms of length >= 3', () => {
-    expect(extractTerms('login error')).toEqual(['login', 'error']);
-  });
-
-  it('filters out terms shorter than 3 characters', () => {
-    expect(extractTerms('a db login')).toEqual(['login']);
-  });
-
-  it('deduplicates terms case-insensitively', () => {
-    const terms = extractTerms('Login login LOGIN');
-    expect(terms).toHaveLength(1);
-    expect(terms[0]!.toLowerCase()).toBe('login');
-  });
-
-  it('sorts longest terms first to prevent partial-match overlap', () => {
-    const terms = extractTerms('err error errors');
-    expect(terms[0]).toBe('errors');
-    expect(terms[1]).toBe('error');
-  });
-
-  it('returns empty array for empty query', () => {
-    expect(extractTerms('')).toEqual([]);
-  });
-
-  it('returns empty array when all terms are too short', () => {
-    expect(extractTerms('a ab')).toEqual([]);
-  });
-
-  it('trims whitespace', () => {
-    expect(extractTerms('  login  error  ')).toEqual(['login', 'error']);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// highlightText
-// ---------------------------------------------------------------------------
-
-describe('highlightText', () => {
-  it('wraps a matching term in **bold**', () => {
-    expect(highlightText('Login failed', ['login'])).toBe('**Login** failed');
-  });
-
-  it('is case-insensitive', () => {
-    expect(highlightText('CRASH on startup', ['crash'])).toBe('**CRASH** on startup');
-  });
-
-  it('highlights multiple terms', () => {
-    const result = highlightText('Login error occurred', ['login', 'error']);
-    expect(result).toBe('**Login** **error** occurred');
-  });
-
-  it('returns original text when no terms match', () => {
-    expect(highlightText('Something unrelated', ['crash'])).toBe('Something unrelated');
-  });
-
-  it('returns original text when terms array is empty', () => {
-    expect(highlightText('Login failed', [])).toBe('Login failed');
-  });
-
-  it('does not match term as substring within a word (word-boundary-aware)', () => {
-    // "or" should NOT match inside "error"
-    expect(highlightText('error occurred', ['or'])).toBe('error occurred');
-  });
-
-  it('escapes special regex characters in terms', () => {
-    // Term with special regex chars should not throw
-    expect(() => highlightText('test (foo)', ['(foo)'])).not.toThrow();
-  });
-
-  it('highlights all occurrences of a term', () => {
-    const result = highlightText('login and login again', ['login']);
-    expect(result).toBe('**login** and **login** again');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// extractSnippet
-// ---------------------------------------------------------------------------
-
-describe('extractSnippet', () => {
-  it('returns full text highlighted when text is short', () => {
-    const text = 'Login error on startup';
-    const result = extractSnippet(text, ['login']);
-    expect(result).toBe('**Login** error on startup');
-  });
-
-  it('returns first ~300 chars around the first match for long text', () => {
-    const prefix = 'x'.repeat(200);
-    const text = `${prefix} login error ${' unrelated text'.repeat(30)}`;
-    const result = extractSnippet(text, ['login']);
-    expect(result).toContain('**login**');
-    expect(result.length).toBeLessThanOrEqual(350); // snippet + some overhead
-  });
-
-  it('centers snippet around first match', () => {
-    const padding = 'word '.repeat(60); // ~300 chars before the match
-    const text = `${padding}crash happens here ${'and more text '.repeat(30)}`;
-    const result = extractSnippet(text, ['crash']);
-    expect(result).toContain('**crash**');
-  });
-
-  it('returns first 300 chars (no highlight) when no term matches', () => {
-    const text = 'a'.repeat(600);
-    const result = extractSnippet(text, ['nomatch']);
-    expect(result).toBe('a'.repeat(300) + '…');
-  });
-
-  it('returns full text (no truncation) when text is shorter than 300 chars and no match', () => {
-    const text = 'Short text with no match';
-    const result = extractSnippet(text, ['nomatch']);
-    expect(result).toBe(text);
-  });
-
-  it('respects custom contextChars parameter', () => {
-    const padding = 'x'.repeat(100);
-    const text = `${padding} crash ${padding}`;
-    const result = extractSnippet(text, ['crash'], 50);
-    expect(result).toContain('**crash**');
-    expect(result.length).toBeLessThanOrEqual(150);
-  });
-});