A modern platform for visual, flexible, and extensible graph-based investigations. For cybersecurity analysts and investigators.
import { describe, it, expect, vi, beforeEach } from 'vitest'
import type { FetchEventSourceInit, EventSourceMessage } from '@microsoft/fetch-event-source'
import type { SSEEnvelope } from './sse'
// Capture the options passed to fetchEventSource so we can drive its callbacks.
const calls: { url: string; opts: FetchEventSourceInit }[] = []
const fetchEventSourceMock = vi.fn((url: string, opts: FetchEventSourceInit) => {
calls.push({ url, opts })
return new Promise(() => {}) // never resolves; we drive callbacks manually
})
vi.mock('@microsoft/fetch-event-source', () => ({
fetchEventSource: (url: string, opts: FetchEventSourceInit) => fetchEventSourceMock(url, opts)
}))
vi.mock('@/stores/auth-store', () => ({
useAuthStore: { getState: () => ({ token: 'tok123' }) }
}))
import { connectSSE } from './sse'
const lastOpts = () => calls[calls.length - 1].opts
const fakeResponse = (status: number, contentType: string) =>
({
ok: status >= 200 && status < 300,
status,
headers: { get: () => contentType }
}) as unknown as Response
// The tests only ever care about `data` — id/event are required by the
// library's type but irrelevant to connectSSE's own parsing.
const message = (data: string): EventSourceMessage => ({ id: '', event: '', data })
beforeEach(() => {
calls.length = 0
fetchEventSourceMock.mockClear()
})
describe('connectSSE', () => {
it('passes the URL and Authorization header from the store', () => {
connectSSE({ url: 'http://x/stream', onMessage: () => {} })
expect(calls[0].url).toBe('http://x/stream')
expect(lastOpts().headers).toEqual({ Authorization: 'Bearer tok123' })
})
it('forwards parsed envelopes and skips "connected"', () => {
const received: SSEEnvelope[] = []
connectSSE({ url: 'http://x', onMessage: (m) => received.push(m) })
const o = lastOpts()
o.onmessage?.(message(JSON.stringify({ event: 'connected', data: 'hi' })))
o.onmessage?.(message(JSON.stringify({ event: 'log', data: '{"msg":"a"}' })))
expect(received).toEqual([{ event: 'log', data: '{"msg":"a"}' }])
})
it('ignores empty and malformed messages without throwing', () => {
const received: SSEEnvelope[] = []
connectSSE({ url: 'http://x', onMessage: (m) => received.push(m) })
const o = lastOpts()
o.onmessage?.(message(''))
o.onmessage?.(message('not-json'))
expect(received).toEqual([])
})
it('aborts the request when the disposer is called', () => {
const dispose = connectSSE({ url: 'http://x', onMessage: () => {} })
expect(lastOpts().signal?.aborted).toBe(false)
dispose()
expect(lastOpts().signal?.aborted).toBe(true)
})
it('throws (no retry) on a non-event-stream open', async () => {
connectSSE({ url: 'http://x', onMessage: () => {} })
await expect(lastOpts().onopen?.(fakeResponse(401, 'application/json'))).rejects.toThrow()
})
it('accepts a valid event-stream open', async () => {
connectSSE({ url: 'http://x', onMessage: () => {} })
await expect(
lastOpts().onopen?.(fakeResponse(200, 'text/event-stream'))
).resolves.toBeUndefined()
})
it('returns increasing backoff for transient errors', () => {
connectSSE({ url: 'http://x', onMessage: () => {} })
const o = lastOpts()
const first = o.onerror?.(new Error('network'))
const second = o.onerror?.(new Error('network'))
expect(first).toBe(2000)
expect(second).toBe(4000)
})
it('rethrows fatal errors from onerror to stop retrying', async () => {
connectSSE({ url: 'http://x', onMessage: () => {} })
const o = lastOpts()
let fatal: unknown
try {
await o.onopen?.(fakeResponse(403, 'application/json'))
} catch (e) {
fatal = e
}
expect(() => o.onerror?.(fatal)).toThrow()
})
it('ignores valid JSON that is not an envelope', () => {
const received: SSEEnvelope[] = []
connectSSE({ url: 'http://x', onMessage: (m) => received.push(m) })
const o = lastOpts()
o.onmessage?.(message('42'))
o.onmessage?.(message('null'))
o.onmessage?.(message('{"data":"no-event"}'))
expect(received).toEqual([])
})
it('calls onError once when the connection promise rejects (non-fatal)', async () => {
const errors: unknown[] = []
fetchEventSourceMock.mockImplementationOnce((url: string, opts: FetchEventSourceInit) => {
calls.push({ url, opts })
return Promise.reject(new Error('boom'))
})
connectSSE({ url: 'http://x', onMessage: () => {}, onError: (e) => errors.push(e) })
await Promise.resolve()
await Promise.resolve()
expect(errors).toHaveLength(1)
expect((errors[0] as Error).message).toBe('boom')
})
})