@dpesch/mantisbt-mcp-server 1.8.3 → 1.9.0

package/tests/tools/issues.test.ts

@@ -7,6 +7,7 @@ import { registerIssueTools } from '../../src/tools/issues.js';
 import { MetadataCache } from '../../src/cache.js';
 import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
 import { MANTIS_RESOLVED_STATUS_ID } from '../../src/constants.js';
+import { clearIssueEnumCache } from '../../src/tools/config.js';
 
 function makeStubCache(projectUsers?: Array<{ id: number; name: string; real_name?: string }>): MetadataCache {
   return {
@@ -31,7 +32,7 @@ const getIssueFixturePath = join(fixturesDir, 'get_issue.json');
 const listIssuesFixturePath = join(fixturesDir, 'list_issues.json');
 
 const getIssueFixture = existsSync(getIssueFixturePath)
-  ? (JSON.parse(readFileSync(getIssueFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string }> })
+  ? (JSON.parse(readFileSync(getIssueFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string; notes?: Array<{ id: number }> }> })
   : { issues: [{ id: 42, summary: 'Test Issue' }] };
 
 const listIssuesFixture = existsSync(listIssuesFixturePath)
@@ -55,6 +56,7 @@ beforeEach(() => {
   client = new MantisClient('https://mantis.example.com', 'test-token');
   registerIssueTools(mockServer as never, client, makeStubCache());
   vi.stubGlobal('fetch', vi.fn());
+  clearIssueEnumCache();
 });
 
 afterEach(() => {
@@ -101,6 +103,139 @@ describe('get_issue', () => {
     expect(result.isError).toBe(true);
     expect(result.content[0]!.text).toContain('Error:');
   });
+
+  it('enthält notes direkt in der Response (kein separater list_notes-Call nötig)', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
+
+    const result = await mockServer.callTool('get_issue', { id: getIssueFixture.issues[0]!.id });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { notes?: Array<{ id: number }> };
+    const fixtureNotes = getIssueFixture.issues[0]!.notes!;
+    expect(Array.isArray(parsed.notes)).toBe(true);
+    expect(parsed.notes!.length).toBe(fixtureNotes.length);
+    expect(parsed.notes![0]!.id).toBe(fixtureNotes[0]!.id);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get_issues
+// ---------------------------------------------------------------------------
+
+describe('get_issues', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('get_issues')).toBe(true);
+  });
+
+  it('gibt ein Array von Issues zurück wenn alle IDs existieren', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Issue 42' }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 43, summary: 'Issue 43' }] })));
+
+    const result = await mockServer.callTool('get_issues', { ids: [42, 43] });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as {
+      issues: Array<{ id: number } | null>;
+      requested: number;
+      found: number;
+      failed: number;
+    };
+    expect(parsed.requested).toBe(2);
+    expect(parsed.found).toBe(2);
+    expect(parsed.failed).toBe(0);
+    expect(parsed.issues[0]?.id).toBe(42);
+    expect(parsed.issues[1]?.id).toBe(43);
+  });
+
+  it('gibt null für nicht gefundene IDs zurück ohne isError zu setzen', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Issue 42' }] })))
+      .mockResolvedValueOnce(makeResponse(404, JSON.stringify({ message: 'Issue not found' })));
+
+    const result = await mockServer.callTool('get_issues', { ids: [42, 9999] });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as {
+      issues: Array<{ id: number } | null>;
+      found: number;
+      failed: number;
+    };
+    expect(parsed.found).toBe(1);
+    expect(parsed.failed).toBe(1);
+    expect(parsed.issues[0]?.id).toBe(42);
+    expect(parsed.issues[1]).toBeNull();
+  });
+
+  it('gibt isError nicht zurück auch wenn alle IDs fehlschlagen', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(404, JSON.stringify({ message: 'Not found' })),
+    );
+
+    const result = await mockServer.callTool('get_issues', { ids: [9001, 9002] });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as {
+      issues: Array<null>;
+      found: number;
+      failed: number;
+    };
+    expect(parsed.found).toBe(0);
+    expect(parsed.failed).toBe(2);
+    expect(parsed.issues).toEqual([null, null]);
+  });
+
+  it('erhält die Reihenfolge der Input-IDs im Ergebnis-Array', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 10, summary: 'A' }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 20, summary: 'B' }] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 30, summary: 'C' }] })));
+
+    const result = await mockServer.callTool('get_issues', { ids: [10, 20, 30] });
+
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues.map((i) => i.id)).toEqual([10, 20, 30]);
+  });
+
+  it('validiert: leeres ids-Array wird abgelehnt', async () => {
+    const result = await mockServer.callTool('get_issues', { ids: [] }, { validate: true });
+    expect(result.isError).toBe(true);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+
+  it('validiert: mehr als 50 IDs werden abgelehnt', async () => {
+    const ids = Array.from({ length: 51 }, (_, i) => i + 1);
+    const result = await mockServer.callTool('get_issues', { ids }, { validate: true });
+    expect(result.isError).toBe(true);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+
+  it('akzeptiert String-IDs via z.coerce', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [{ id: 42, summary: 'Test' }] })),
+    );
+
+    const result = await mockServer.callTool('get_issues', { ids: ['42'] }, { validate: true });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues[0]?.id).toBe(42);
+  });
+
+  it('führt alle Requests aus (Concurrency-Nachweis mit 6 IDs)', async () => {
+    Array.from({ length: 6 }, (_, i) => {
+      vi.mocked(fetch).mockResolvedValueOnce(
+        makeResponse(200, JSON.stringify({ issues: [{ id: i + 1, summary: 'x' }] })),
+      );
+    });
+
+    const result = await mockServer.callTool('get_issues', { ids: [1, 2, 3, 4, 5, 6] });
+
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(6);
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { requested: number };
+    expect(parsed.requested).toBe(6);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -235,7 +370,6 @@ describe('create_issue', () => {
     expect(result.isError).toBe(true);
     expect(result.content[0]!.text).toContain('schwerer Fehler');
     expect(result.content[0]!.text).toContain('minor');
-    expect(fetch).not.toHaveBeenCalled();
   });
 
   it('creates issue without any optional fields (backward compatibility)', async () => {
@@ -330,7 +464,6 @@ describe('create_issue', () => {
     expect(result.isError).toBe(true);
     expect(result.content[0]!.text).toContain('immer');
     expect(result.content[0]!.text).toContain('always');
-    expect(fetch).not.toHaveBeenCalled();
   });
 
   it('returns error for empty reproducibility string', async () => {
@@ -343,7 +476,6 @@ describe('create_issue', () => {
     }, { validate: true });
 
     expect(result.isError).toBe(true);
-    expect(fetch).not.toHaveBeenCalled();
   });
 
   it('sends view_state as { name } object', async () => {
@@ -655,6 +787,45 @@ describe('list_issues', () => {
     expect(parsedUpper.issues.length).toBe(parsedLower.issues.length);
     expect(parsedUpper.issues).toEqual(parsedLower.issues);
   });
+
+  it('status canonical name matches by ID even when API returns localized status names', async () => {
+    // Simulate a German MantisBT installation where issue.status.name is localized
+    const localizedFixture = {
+      issues: [
+        { id: 1, status: { id: 10, name: 'Neu' } },
+        { id: 2, status: { id: 80, name: 'Erledigt' } },
+        { id: 3, status: { id: 10, name: 'Neu' } },
+      ],
+      total_count: 3,
+    };
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(localizedFixture)));
+
+    const result = await mockServer.callTool('list_issues', { status: 'new', page: 1, page_size: 50 });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues).toHaveLength(2);
+    expect(parsed.issues.map(i => i.id)).toEqual([1, 3]);
+  });
+
+  it('status filter falls back to name comparison for non-canonical values', async () => {
+    // "Neu" is not a canonical status name → falls back to name comparison
+    const localizedFixture = {
+      issues: [
+        { id: 1, status: { id: 10, name: 'Neu' } },
+        { id: 2, status: { id: 80, name: 'Erledigt' } },
+      ],
+      total_count: 2,
+    };
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(localizedFixture)));
+
+    const result = await mockServer.callTool('list_issues', { status: 'Neu', page: 1, page_size: 50 });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues).toHaveLength(1);
+    expect(parsed.issues[0]!.id).toBe(1);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -736,3 +907,274 @@ describe('update_issue – fields allowlist', () => {
     expect(vi.mocked(fetch)).not.toHaveBeenCalled();
   });
 });
+
+// ---------------------------------------------------------------------------
+// update_issue – dry_run
+// ---------------------------------------------------------------------------
+
+describe('update_issue – dry_run', () => {
+  it('returns preview payload without calling the API', async () => {
+    const result = await mockServer.callTool(
+      'update_issue',
+      { id: 42, fields: { summary: 'Preview title', status: { name: 'resolved' } }, dry_run: true },
+      { validate: true },
+    );
+
+    expect(result.isError).toBeUndefined();
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+
+    const parsed = JSON.parse(result.content[0]!.text) as { dry_run: boolean; id: number; would_patch: Record<string, unknown> };
+    expect(parsed.dry_run).toBe(true);
+    expect(parsed.id).toBe(42);
+    expect(parsed.would_patch).toEqual({ summary: 'Preview title', status: { name: 'resolved' } });
+  });
+
+  it('defaults to false (normal update) when dry_run is omitted', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ issue: { id: 42, summary: 'Updated' } })));
+
+    const result = await mockServer.callTool(
+      'update_issue',
+      { id: 42, fields: { summary: 'Updated' } },
+      { validate: true },
+    );
+
+    expect(result.isError).toBeUndefined();
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
+  });
+
+  it('also rejects unknown fields in dry_run mode without calling the API', async () => {
+    const result = await mockServer.callTool(
+      'update_issue',
+      { id: 42, fields: { unknown_field: 'bad' }, dry_run: true },
+      { validate: true },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update_issue – enum resolution
+// ---------------------------------------------------------------------------
+
+describe('update_issue – enum resolution', () => {
+  it('resolves canonical severity name to { id } before sending to API', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
+    );
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { severity: { name: 'major' } } },
+      { validate: true },
+    );
+
+    // Only one fetch call (the PATCH itself — canonical lookup needs no API call)
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.severity).toEqual({ id: 60 }); // major = id 60
+  });
+
+  it('resolves canonical priority name to { id } before sending to API', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
+    );
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { priority: { name: 'high' } } },
+      { validate: true },
+    );
+
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.priority).toEqual({ id: 40 }); // high = id 40
+  });
+
+  it('resolves canonical status name to { id } before sending to API', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
+    );
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { status: { name: 'resolved' } } },
+      { validate: true },
+    );
+
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.status).toEqual({ id: 80 }); // resolved = id 80
+  });
+
+  it('does not resolve when id is already provided', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
+    );
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { severity: { id: 60 } } },
+      { validate: true },
+    );
+
+    // Only one fetch call — no enum resolution needed
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce();
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.severity).toEqual({ id: 60 });
+  });
+
+  it('resolves localized enum name to { id } via live enum lookup', async () => {
+    // First fetch: config endpoint for enum data
+    // Second fetch: the actual PATCH
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({
+        configs: [{
+          option: 'severity_enum_string',
+          value: [
+            { id: 50, name: 'Kleiner Fehler' },
+            { id: 60, name: 'Großer Fehler' },
+          ],
+        }],
+      })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issue: { id: 1 } })));
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { severity: { name: 'Großer Fehler' } } },
+      { validate: true },
+    );
+
+    // Call 0 = config endpoint, Call 1 = PATCH
+    const patchBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as Record<string, unknown>;
+    expect(patchBody.severity).toEqual({ id: 60 });
+  });
+
+  it('passes unknown enum name through unchanged when resolution fails', async () => {
+    // Config returns no useful data → name stays unchanged
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ configs: [] })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issue: { id: 1 } })));
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { severity: { name: 'völlig_unbekannt' } } },
+      { validate: true },
+    );
+
+    const patchBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as Record<string, unknown>;
+    expect(patchBody.severity).toEqual({ name: 'völlig_unbekannt' });
+  });
+
+  it('resolves multiple enum fields in one patch call', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issue: { id: 1 } })),
+    );
+
+    await mockServer.callTool(
+      'update_issue',
+      { id: 1, fields: { status: { name: 'resolved' }, priority: { name: 'high' }, severity: { name: 'major' } } },
+      { validate: true },
+    );
+
+    expect(vi.mocked(fetch)).toHaveBeenCalledOnce(); // all canonical → single PATCH call
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
+    expect(body.status).toEqual({ id: 80 });
+    expect(body.priority).toEqual({ id: 40 });
+    expect(body.severity).toEqual({ id: 60 });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list_issues – date filters
+// ---------------------------------------------------------------------------
+
+function makeIssuePage(issues: Array<{ id: number; updated_at: string; created_at: string }>) {
+  return { issues, total_count: issues.length };
+}
+
+describe('list_issues – updated_after filter', () => {
+  it('returns only issues updated after the given date', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
+      { id: 1, updated_at: '2026-03-26T10:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+      { id: 2, updated_at: '2026-03-23T10:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+      { id: 3, updated_at: '2026-03-25T00:00:01Z', created_at: '2026-03-01T00:00:00Z' },
+    ]))));
+
+    const result = await mockServer.callTool('list_issues', {
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues.map(i => i.id)).toEqual([1, 3]);
+  });
+
+  it('returns an empty list when no issue matches', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
+      { id: 1, updated_at: '2026-03-20T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+    ]))));
+
+    const result = await mockServer.callTool('list_issues', {
+      updated_after: '2026-03-25T00:00:00Z',
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<unknown> };
+    expect(parsed.issues).toHaveLength(0);
+  });
+
+  it('stops scanning pages when all issues in a batch are older than updated_after (early-exit)', async () => {
+    // Page 1: one matching issue, one too old
+    // Page 2: should NOT be fetched because the last item of page 1 is already older
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(makeIssuePage([
+        { id: 10, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+        { id: 9,  updated_at: '2026-03-20T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+      ]))))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify(makeIssuePage([
+        { id: 8, updated_at: '2026-03-18T00:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+      ]))));
+
+    await mockServer.callTool('list_issues', {
+      updated_after: '2026-03-25T00:00:00Z',
+      page_size: 50,
+    });
+
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('list_issues – created_after filter', () => {
+  it('returns only issues created after the given date', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
+      { id: 1, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-26T00:00:00Z' },
+      { id: 2, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-23T00:00:00Z' },
+    ]))));
+
+    const result = await mockServer.callTool('list_issues', {
+      created_after: '2026-03-25T00:00:00Z',
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues.map(i => i.id)).toEqual([1]);
+  });
+});
+
+describe('list_issues – combined date window', () => {
+  it('returns only issues within the updated_after + updated_before window', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(makeIssuePage([
+      { id: 1, updated_at: '2026-03-22T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // in window
+      { id: 2, updated_at: '2026-03-19T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // too old
+      { id: 3, updated_at: '2026-03-26T00:00:00Z', created_at: '2026-03-01T00:00:00Z' }, // too new
+    ]))));
+
+    const result = await mockServer.callTool('list_issues', {
+      updated_after:  '2026-03-20T00:00:00Z',
+      updated_before: '2026-03-25T00:00:00Z',
+    });
+
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: Array<{ id: number }> };
+    expect(parsed.issues.map(i => i.id)).toEqual([1]);
+  });
+});

package/tests/utils/date-filter.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest';
+import { matchesDateFilter } from '../../src/date-filter.js';
+
+describe('matchesDateFilter', () => {
+
+  // ---------------------------------------------------------------------------
+  // No filter → always pass
+  // ---------------------------------------------------------------------------
+
+  it('returns true when no filter is set', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-20T10:00:00Z', created_at: '2026-03-01T00:00:00Z' },
+      {}
+    )).toBe(true);
+  });
+
+  it('returns true for an item with no dates when no filter is set', () => {
+    expect(matchesDateFilter({}, {})).toBe(true);
+  });
+
+  // ---------------------------------------------------------------------------
+  // updated_after
+  // ---------------------------------------------------------------------------
+
+  it('updated_after: passes when updated_at is after the threshold', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-25T12:00:00Z' },
+      { updated_after: '2026-03-24T00:00:00Z' }
+    )).toBe(true);
+  });
+
+  it('updated_after: fails when updated_at is before the threshold', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-23T12:00:00Z' },
+      { updated_after: '2026-03-24T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('updated_after: fails when updated_at equals the threshold (exclusive)', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-24T00:00:00Z' },
+      { updated_after: '2026-03-24T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('updated_after: fails when updated_at is missing', () => {
+    expect(matchesDateFilter(
+      { created_at: '2026-03-25T00:00:00Z' },
+      { updated_after: '2026-03-24T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  // ---------------------------------------------------------------------------
+  // updated_before
+  // ---------------------------------------------------------------------------
+
+  it('updated_before: passes when updated_at is before the threshold', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-20T00:00:00Z' },
+      { updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(true);
+  });
+
+  it('updated_before: fails when updated_at is after the threshold', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-26T00:00:00Z' },
+      { updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('updated_before: fails when updated_at equals the threshold (exclusive)', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-25T00:00:00Z' },
+      { updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('updated_before: fails when updated_at is missing', () => {
+    expect(matchesDateFilter(
+      {},
+      { updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  // ---------------------------------------------------------------------------
+  // created_after
+  // ---------------------------------------------------------------------------
+
+  it('created_after: passes when created_at is after the threshold', () => {
+    expect(matchesDateFilter(
+      { created_at: '2026-03-25T12:00:00Z' },
+      { created_after: '2026-03-24T00:00:00Z' }
+    )).toBe(true);
+  });
+
+  it('created_after: fails when created_at is before the threshold', () => {
+    expect(matchesDateFilter(
+      { created_at: '2026-03-23T00:00:00Z' },
+      { created_after: '2026-03-24T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('created_after: fails when created_at is missing', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-25T00:00:00Z' },
+      { created_after: '2026-03-24T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  // ---------------------------------------------------------------------------
+  // created_before
+  // ---------------------------------------------------------------------------
+
+  it('created_before: passes when created_at is before the threshold', () => {
+    expect(matchesDateFilter(
+      { created_at: '2026-03-20T00:00:00Z' },
+      { created_before: '2026-03-25T00:00:00Z' }
+    )).toBe(true);
+  });
+
+  it('created_before: fails when created_at is after the threshold', () => {
+    expect(matchesDateFilter(
+      { created_at: '2026-03-26T00:00:00Z' },
+      { created_before: '2026-03-25T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Combined filters (time window)
+  // ---------------------------------------------------------------------------
+
+  it('updated_after + updated_before: passes when updated_at is within window', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-22T00:00:00Z' },
+      { updated_after: '2026-03-20T00:00:00Z', updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(true);
+  });
+
+  it('updated_after + updated_before: fails when updated_at is outside window', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-26T00:00:00Z' },
+      { updated_after: '2026-03-20T00:00:00Z', updated_before: '2026-03-25T00:00:00Z' }
+    )).toBe(false);
+  });
+
+  it('all four filters: passes only when both dates are within their windows', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-22T00:00:00Z', created_at: '2026-03-10T00:00:00Z' },
+      {
+        updated_after: '2026-03-20T00:00:00Z',
+        updated_before: '2026-03-25T00:00:00Z',
+        created_after:  '2026-03-05T00:00:00Z',
+        created_before: '2026-03-15T00:00:00Z',
+      }
+    )).toBe(true);
+  });
+
+  it('all four filters: fails when one date is out of range', () => {
+    expect(matchesDateFilter(
+      { updated_at: '2026-03-22T00:00:00Z', created_at: '2026-03-16T00:00:00Z' }, // created_at too late
+      {
+        updated_after: '2026-03-20T00:00:00Z',
+        updated_before: '2026-03-25T00:00:00Z',
+        created_after:  '2026-03-05T00:00:00Z',
+        created_before: '2026-03-15T00:00:00Z',
+      }
+    )).toBe(false);
+  });
+});