| import { describe, expect, it } from 'vitest' |
| import { |
| advanceCursor, |
| buildLogsQuery, |
| clampMessage, |
| collectProviders, |
| formatLogTime, |
| isLongMessage, |
| levelsCsv, |
| mergeEntries, |
| toggleLevel, |
| type LogEntry, |
| type LogLevel, |
| } from './logs' |
|
|
| function entry(id: number, extra: Partial<LogEntry> = {}): LogEntry { |
| return { |
| id, |
| ts: '2024-01-02T03:04:05.678Z', |
| level: 'info', |
| message: `message ${id}`, |
| ...extra, |
| } |
| } |
|
|
| describe('buildLogsQuery', () => { |
| it('always sends the selected levels as a canonically ordered CSV', () => { |
| expect(buildLogsQuery({ levels: ['error', 'debug', 'warn'] })) |
| .toBe('/api/logs?levels=debug%2Cwarn%2Cerror&limit=200') |
| }) |
|
|
| it('omits blank search and the "all" provider sentinel', () => { |
| expect(buildLogsQuery({ levels: ['warn'], q: ' ', provider: 'all' })) |
| .toBe('/api/logs?levels=warn&limit=200') |
| }) |
|
|
| it('sends trimmed search, provider and cursor when present', () => { |
| const url = buildLogsQuery({ |
| levels: ['warn', 'error'], |
| q: ' rate limit ', |
| provider: 'groq', |
| sinceId: 123, |
| limit: 200, |
| }) |
| expect(url).toBe('/api/logs?levels=warn%2Cerror&q=rate+limit&provider=groq&sinceId=123&limit=200') |
| }) |
|
|
| it('treats sinceId 0 as a real cursor but null as the first fetch', () => { |
| expect(buildLogsQuery({ levels: ['info'], sinceId: 0 })).toContain('sinceId=0') |
| expect(buildLogsQuery({ levels: ['info'], sinceId: null })).not.toContain('sinceId') |
| }) |
|
|
| it('collapses duplicate levels', () => { |
| expect(levelsCsv(['warn', 'warn', 'debug'])).toBe('debug,warn') |
| }) |
| }) |
|
|
| describe('mergeEntries', () => { |
| it('appends new entries in arrival order', () => { |
| const merged = mergeEntries([entry(1), entry(2)], [entry(3), entry(4)]) |
| expect(merged.map(e => e.id)).toEqual([1, 2, 3, 4]) |
| }) |
|
|
| it('never duplicates an id already in the buffer', () => { |
| const merged = mergeEntries([entry(1), entry(2)], [entry(2), entry(3)]) |
| expect(merged.map(e => e.id)).toEqual([1, 2, 3]) |
| }) |
|
|
| it('de-duplicates within a single incoming page', () => { |
| const merged = mergeEntries([], [entry(1), entry(1), entry(2)]) |
| expect(merged.map(e => e.id)).toEqual([1, 2]) |
| }) |
|
|
| it('returns the same array when nothing new arrived', () => { |
| const buffer = [entry(1), entry(2)] |
| expect(mergeEntries(buffer, [])).toBe(buffer) |
| expect(mergeEntries(buffer, [entry(2)])).toBe(buffer) |
| }) |
|
|
| it('evicts the oldest entries once the cap is passed', () => { |
| const buffer = [entry(1), entry(2), entry(3)] |
| const merged = mergeEntries(buffer, [entry(4), entry(5)], 3) |
| expect(merged.map(e => e.id)).toEqual([3, 4, 5]) |
| }) |
|
|
| it('caps a single oversized page too', () => { |
| const page = Array.from({ length: 10 }, (_, i) => entry(i + 1)) |
| expect(mergeEntries([], page, 4).map(e => e.id)).toEqual([7, 8, 9, 10]) |
| }) |
| }) |
|
|
| describe('advanceCursor', () => { |
| it('takes the server nextId when entries arrived', () => { |
| expect(advanceCursor(10, { entries: [entry(11), entry(12)], nextId: 12 })).toBe(12) |
| }) |
|
|
| it('still advances when the page came back empty', () => { |
| |
| |
| expect(advanceCursor(10, { entries: [], nextId: 42 })).toBe(42) |
| }) |
|
|
| it('accepts nextId 0 on an empty ring', () => { |
| expect(advanceCursor(null, { entries: [], nextId: 0 })).toBe(0) |
| }) |
|
|
| it('falls back to the highest seen id when nextId is unusable', () => { |
| const broken = { entries: [entry(7), entry(9)], nextId: undefined as unknown as number } |
| expect(advanceCursor(3, broken)).toBe(9) |
| expect(advanceCursor(20, { entries: [], nextId: NaN })).toBe(20) |
| }) |
| }) |
|
|
| describe('toggleLevel', () => { |
| it('adds a level back in canonical order, not at the end', () => { |
| expect(toggleLevel(['warn', 'error'], 'debug')).toEqual(['debug', 'warn', 'error']) |
| }) |
|
|
| it('removes a selected level', () => { |
| expect(toggleLevel(['info', 'warn', 'error'], 'warn')).toEqual(['info', 'error']) |
| }) |
|
|
| it('can empty the selection', () => { |
| expect(toggleLevel(['error'], 'error')).toEqual([]) |
| }) |
|
|
| it('round-trips', () => { |
| const start: LogLevel[] = ['info', 'warn', 'error'] |
| expect(toggleLevel(toggleLevel(start, 'debug'), 'debug')).toEqual(start) |
| }) |
| }) |
|
|
| describe('collectProviders', () => { |
| it('accumulates and sorts, ignoring entries without a provider', () => { |
| const providers = collectProviders(['groq'], [ |
| entry(1, { provider: 'cerebras' }), |
| entry(2), |
| entry(3, { provider: 'groq' }), |
| ]) |
| expect(providers).toEqual(['cerebras', 'groq']) |
| }) |
|
|
| it('returns the same array when no new provider showed up', () => { |
| const known = ['groq'] |
| expect(collectProviders(known, [entry(1, { provider: 'groq' })])).toBe(known) |
| expect(collectProviders(known, [])).toBe(known) |
| }) |
| }) |
|
|
| describe('formatLogTime', () => { |
| it('formats local wall-clock time as HH:MM:SS.mmm', () => { |
| |
| const ts = new Date(2024, 0, 2, 3, 4, 5, 678).toISOString() |
| expect(formatLogTime(ts)).toBe('03:04:05.678') |
| }) |
|
|
| it('zero-pads the milliseconds', () => { |
| const ts = new Date(2024, 0, 2, 23, 59, 59, 7).toISOString() |
| expect(formatLogTime(ts)).toBe('23:59:59.007') |
| }) |
|
|
| it('degrades to a placeholder of the same width on a bad timestamp', () => { |
| expect(formatLogTime('not a date')).toBe('--:--:--.---') |
| }) |
| }) |
|
|
| describe('message clamping', () => { |
| it('leaves short messages alone', () => { |
| expect(isLongMessage('short', 10)).toBe(false) |
| expect(clampMessage('short', 10)).toBe('short') |
| }) |
|
|
| it('clamps long messages with an ellipsis', () => { |
| const long = 'x'.repeat(50) |
| expect(isLongMessage(long, 10)).toBe(true) |
| expect(clampMessage(long, 10)).toBe('xxxxxxxxxx…') |
| }) |
| }) |
|
|
