@remember-web/sse 0.1.0-alpha.1

package/src/core/SseClient.connection.test.ts

@@ -0,0 +1,863 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+
+import type { SseStatus } from './types';
+
+import {
+  createHarness,
+  FakeEventSource,
+  lastSource,
+  openConnection,
+  setupFakeTimers,
+} from '../testing';
+
+setupFakeTimers();
+
+describe('연결 수립', () => {
+  it('티켓을 발급받아 티켓이 담긴 주소로 연결하고, hello를 받으면 open 상태가 됩니다', async () => {
+    const { client } = createHarness();
+    const statuses: SseStatus[] = [];
+    client.onStatus((status) => statuses.push(status));
+
+    client.connect();
+    expect(client.status).toBe('connecting');
+
+    await vi.advanceTimersByTimeAsync(0);
+    expect(FakeEventSource.instances).toHaveLength(1);
+    expect(lastSource().url).toBe(
+      'https://sse.example.com/v1/events?ticket=ticket-1'
+    );
+    expect(client.status).toBe('connecting');
+
+    lastSource().dispatch('hello');
+    expect(client.status).toBe('open');
+    expect(statuses).toEqual(['connecting', 'open']);
+  });
+
+  it('connect()를 여러 번 불러도 티켓 발급과 연결은 한 번만 일어납니다', async () => {
+    const { client, ticketRequests } = createHarness();
+
+    client.connect();
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(ticketRequests()).toHaveLength(1);
+    expect(FakeEventSource.instances).toHaveLength(1);
+  });
+
+  it('연결 전에 등록한 구독도, 연결 후에 등록한 구독도 이벤트를 받습니다', async () => {
+    const { client } = createHarness();
+    const before: { id: string }[] = [];
+    const after: { id: string }[] = [];
+
+    client.on('demo.created', (event) => before.push(event));
+    await openConnection(client);
+    client.on('demo.created', (event) => after.push(event));
+
+    lastSource().dispatch('demo.created', '{"id":"a"}');
+    expect(before).toEqual([{ id: 'a' }]);
+    expect(after).toEqual([{ id: 'a' }]);
+  });
+
+  // 서버가 JSON이 아닌 페이로드를 보내도 SDK가 임의로 버리지 않습니다 — 해석은 소비처 몫입니다
+  it('JSON이 아닌 페이로드는 원문 문자열로 배달되고, 연결은 유지됩니다', async () => {
+    const { client } = createHarness();
+    const received: unknown[] = [];
+    client.on('demo.created', (payload) => received.push(payload));
+
+    await openConnection(client);
+    lastSource().dispatch('demo.created', 'not-json');
+    lastSource().dispatch('demo.created', '{"id":"a"}');
+
+    expect(received).toEqual(['not-json', { id: 'a' }]);
+    expect(client.status).toBe('open');
+  });
+
+  it('티켓 발급 응답이 오지 않으면 10초 후 실패로 처리하고 reconnecting이 됩니다', async () => {
+    const { client } = createHarness({
+      fetch: (() =>
+        new Promise(() => {})) as unknown as typeof globalThis.fetch,
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect(client.status).toBe('reconnecting');
+  });
+
+  it('EventSource 생성 자체가 실패하면(잘못된 주소 등) 재시도 없이 fatal이 되고 logger.error로 알립니다', async () => {
+    const errors: string[] = [];
+    class ThrowingEventSource {
+      constructor() {
+        throw new Error('invalid url');
+      }
+    }
+    const { client } = createHarness({
+      eventSource: ThrowingEventSource as unknown as typeof EventSource,
+      logger: { warn: () => {}, error: (message) => errors.push(message) },
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('fatal');
+    expect(errors).toHaveLength(1);
+  });
+
+  // 생성의 동기 throw는 설정 실수라 재시도가 무의미합니다 — 네트워크성 실패(onerror)는 reconnecting으로 갑니다
+  it('EventSource 생성 실패의 fatal은 사유를 config로 알립니다', async () => {
+    class ThrowingEventSource {
+      constructor() {
+        throw new Error('invalid url');
+      }
+    }
+    const { client } = createHarness({
+      eventSource: ThrowingEventSource as unknown as typeof EventSource,
+      logger: { warn: () => {}, error: () => {} },
+    });
+    const causes: unknown[] = [];
+    client.on('fatal', (payload) => causes.push(payload));
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(causes).toEqual([{ cause: 'config' }]);
+  });
+
+  it('연결은 됐지만 hello가 오지 않으면 10초 후 연결을 닫고 reconnecting이 됩니다', async () => {
+    const { client } = createHarness();
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    const source = lastSource();
+
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect(source.closed).toBe(true);
+    expect(client.status).toBe('reconnecting');
+  });
+});
+
+describe('티켓 발급 실패', () => {
+  it('티켓 발급이 401로 거부되면 fatal이 되고 다시 시도하지 않습니다', async () => {
+    const { client, ticketRequests, failTicketsWith } = createHarness();
+    failTicketsWith(401);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('fatal');
+
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(ticketRequests()).toHaveLength(1);
+  });
+
+  it('fatal 상태에서 connect()를 다시 불러도 연결하지 않고, disconnect()가 먼저 필요함을 logger.warn으로 알립니다', async () => {
+    const warnings: string[] = [];
+    const { client, ticketRequests, failTicketsWith } = createHarness({
+      logger: { warn: (message) => warnings.push(message), error: () => {} },
+    });
+    failTicketsWith(401);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('fatal');
+    const warningsBefore = warnings.length;
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('fatal');
+    expect(ticketRequests()).toHaveLength(1);
+    expect(warnings).toHaveLength(warningsBefore + 1);
+    expect(warnings.at(-1)).toContain(
+      'fatal 상태에서는 connect()가 무시됩니다'
+    );
+  });
+
+  // 소비처가 원인별 안내(재로그인·한도)를 가르는 채널입니다 — status 'fatal'만으로는 구분할 수 없습니다
+  it.each([401, 403] as const)(
+    '티켓 발급이 %i로 거부되면 사유(auth)를 fatal 이벤트로 알립니다',
+    async (status) => {
+      const { client, failTicketsWith } = createHarness();
+      failTicketsWith(status);
+      const causes: unknown[] = [];
+      client.on('fatal', (payload) => causes.push(payload));
+
+      client.connect();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(causes).toEqual([{ cause: 'auth', status }]);
+    }
+  );
+
+  it('티켓 발급이 429로 거부되면 사유(rate_limit)를 알리고, 알릴 때는 전이가 이미 끝나 있습니다', async () => {
+    const warnings: string[] = [];
+    const { client, failTicketsWith } = createHarness({
+      logger: { warn: (message) => warnings.push(message), error: () => {} },
+    });
+    failTicketsWith(429);
+    const seen: unknown[] = [];
+    client.on('fatal', (payload) =>
+      seen.push({ payload, status: client.status })
+    );
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(seen).toEqual([
+      { payload: { cause: 'rate_limit', status: 429 }, status: 'fatal' },
+    ]);
+    expect(warnings.at(-1)).toContain('429');
+  });
+
+  it('티켓 발급이 5xx로 실패하면 대기 시간이 지난 뒤 자동으로 다시 발급을 시도합니다', async () => {
+    const { client, ticketRequests, failTicketsWith } = createHarness();
+    failTicketsWith(500);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('reconnecting');
+
+    failTicketsWith(null);
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(ticketRequests()).toHaveLength(2);
+    expect(client.status).toBe('connecting');
+  });
+
+  it('getAuthToken이 예외를 던지면 재시도 없이 fatal(auth_callback)이 되고 logger.error로 알립니다', async () => {
+    const errors: { message: string; meta?: unknown }[] = [];
+    const { client, ticketRequests } = createHarness({
+      getAuthToken: () => {
+        throw new Error('broken callback');
+      },
+      logger: {
+        warn: () => {},
+        error: (message, meta) => errors.push({ message, meta }),
+      },
+    });
+    const seen: unknown[] = [];
+    client.on('fatal', (payload) =>
+      seen.push({ payload, status: client.status })
+    );
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(seen).toEqual([
+      { payload: { cause: 'auth_callback' }, status: 'fatal' },
+    ]);
+    expect(errors.at(-1)?.message).toContain('getAuthToken');
+    // 콜백이 던진 원본 예외가 로그에 보존됩니다 — 소비처가 자기 버그를 고칠 단서
+    expect(
+      errors.some(({ meta }) => (meta as Error)?.message === 'broken callback')
+    ).toBe(true);
+
+    // 발급 요청(fetch)까지 가지 않았고, 재시도도 예약되지 않습니다
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(ticketRequests()).toHaveLength(0);
+  });
+
+  it('티켓 응답이 200인데 본문 파싱에 실패하면 fatal이 아니라 재시도합니다', async () => {
+    const brokenBodyFetch = (async () =>
+      ({
+        ok: true,
+        status: 200,
+        json: async () => {
+          throw new Error('not json');
+        },
+      }) as unknown as Response) as unknown as typeof globalThis.fetch;
+    const { client } = createHarness({ fetch: brokenBodyFetch });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('reconnecting');
+  });
+
+  it('티켓 응답 본문에 ticket이 없으면(형태 위반) 그 티켓으로 연결하지 않고 재시도하며, logger.warn으로 알립니다', async () => {
+    const wrongShapeFetch = (async () =>
+      ({
+        ok: true,
+        status: 200,
+        json: async () => ({}),
+      }) as unknown as Response) as unknown as typeof globalThis.fetch;
+    const warnings: string[] = [];
+    const { client } = createHarness({
+      fetch: wrongShapeFetch,
+      logger: { warn: (message) => warnings.push(message), error: () => {} },
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(FakeEventSource.instances).toHaveLength(0);
+    expect(client.status).toBe('reconnecting');
+    // stalled·fatal 어느 쪽에도 닿지 않는 침묵 분기라 이 로그가 유일한 단서입니다
+    expect(warnings.at(-1)).toContain('본문이 계약');
+  });
+});
+
+describe('재연결', () => {
+  it('수신 중 연결이 끊기면 기존 연결을 닫고 다시 수립하며, 두 번째 open부터 resync 이벤트를 알립니다', async () => {
+    const { client } = createHarness();
+    let resyncCount = 0;
+    client.on('resync', () => {
+      resyncCount += 1;
+    });
+
+    await openConnection(client);
+    const firstSource = lastSource();
+    expect(resyncCount).toBe(0);
+
+    firstSource.error();
+    expect(firstSource.closed).toBe(true);
+    expect(client.status).toBe('reconnecting');
+
+    await vi.advanceTimersByTimeAsync(1000);
+    lastSource().dispatch('hello');
+    expect(client.status).toBe('open');
+    expect(resyncCount).toBe(1);
+    expect(FakeEventSource.instances).toHaveLength(2);
+  });
+
+  it('이미 닫힌 이전 연결에서 뒤늦게 hello가 도착해도 새 연결의 상태는 바뀌지 않습니다', async () => {
+    const { client } = createHarness();
+
+    await openConnection(client);
+    const firstSource = lastSource();
+
+    client.disconnect();
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('connecting');
+
+    // 스펙 위반 소스 흉내 — close 후에도 남은 리스너로 늦은 hello를 직접 배달합니다
+    firstSource.listeners.get('hello')?.forEach((listener) => listener({}));
+    expect(client.status).toBe('connecting');
+
+    lastSource().dispatch('hello');
+    expect(client.status).toBe('open');
+  });
+
+  it('재연결된 뒤에도 기존 구독이 계속 이벤트를 받습니다', async () => {
+    const { client } = createHarness();
+    const received: { id: string }[] = [];
+    client.on('demo.created', (event) => received.push(event));
+
+    await openConnection(client);
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(1000);
+    lastSource().dispatch('hello');
+
+    lastSource().dispatch('demo.created', '{"id":"b"}');
+    expect(received).toEqual([{ id: 'b' }]);
+  });
+
+  it('재연결할 때는 그 시점의 최신 토큰으로 티켓을 발급합니다', async () => {
+    let token = 'token-1';
+    const { client, ticketRequests } = createHarness({
+      getAuthToken: () => token,
+    });
+
+    await openConnection(client);
+    token = 'token-2';
+    lastSource().error();
+    await vi.advanceTimersByTimeAsync(1000);
+
+    expect(ticketRequests().at(-1)?.authorization).toBe('Bearer token-2');
+  });
+
+  it('연결이 성공하면 재시도 대기 시간이 처음(1초)으로 되돌아갑니다', async () => {
+    const { client, ticketRequests, failTicketsWith } = createHarness();
+    failTicketsWith(500);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    failTicketsWith(null);
+    await vi.advanceTimersByTimeAsync(2000);
+    lastSource().dispatch('hello');
+    expect(ticketRequests()).toHaveLength(3);
+
+    lastSource().error();
+    // 대기 시간이 초기화되지 않았다면 다음 지연은 4초라서, 1초 경과 시점에는 재시도가 일어나지 않아야 합니다
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(ticketRequests()).toHaveLength(4);
+  });
+
+  it('서버가 goaway로 재연결을 예고하면 대기 없이 즉시 다시 연결합니다', async () => {
+    const { client, ticketRequests } = createHarness();
+
+    await openConnection(client);
+    lastSource().dispatch('goaway');
+    expect(client.status).toBe('reconnecting');
+
+    await vi.advanceTimersByTimeAsync(0);
+    expect(ticketRequests()).toHaveLength(2);
+  });
+
+  it('goaway로 재수립하면 그 연결은 재연결이라 resync를 알립니다', async () => {
+    const { client } = createHarness();
+    let resyncCount = 0;
+    client.on('resync', () => {
+      resyncCount += 1;
+    });
+
+    await openConnection(client);
+    lastSource().dispatch('goaway', JSON.stringify({ action: 'retry' }));
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+
+    // retry는 같은 세션이 이어지는 것이라, 끊긴 구간에 놓친 이벤트가 있을 수 있습니다
+    expect(resyncCount).toBe(1);
+  });
+
+  it('goaway의 action이 close면 재연결하지 않고 closed가 됩니다', async () => {
+    const { client, ticketRequests } = createHarness();
+
+    await openConnection(client);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'user_logout', action: 'close' })
+    );
+
+    expect(client.status).toBe('closed');
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(ticketRequests()).toHaveLength(1);
+  });
+
+  it('goaway의 페이로드를 구독자에게 그대로 전달합니다 — reason 대응은 소비처 몫입니다', async () => {
+    const { client } = createHarness();
+    const received: unknown[] = [];
+    client.on('goaway', (payload) => received.push(payload));
+
+    await openConnection(client);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'maintenance', action: 'close' })
+    );
+
+    expect(received).toEqual([{ reason: 'maintenance', action: 'close' }]);
+  });
+
+  it('모르는 reason·action은 페이로드에서 빼고 전달합니다', async () => {
+    const { client } = createHarness();
+    const received: unknown[] = [];
+    client.on('goaway', (payload) => received.push(payload));
+
+    await openConnection(client);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'alien-reason', action: 'unknown-action' })
+    );
+
+    expect(received).toEqual([{}]);
+  });
+
+  // 알림이 전이보다 먼저면 핸들러가 보는 status가 아직 open이라, 그 자리의 connect()가 조용히 무시됩니다
+  it('goaway를 알릴 때는 상태 전이가 이미 끝나 있어, 핸들러가 그 자리에서 다시 연결할 수 있습니다', async () => {
+    const { client, ticketRequests } = createHarness();
+    const seen: string[] = [];
+    client.on('goaway', () => {
+      seen.push(client.status);
+      client.connect();
+    });
+
+    await openConnection(client);
+    lastSource().dispatch('goaway', JSON.stringify({ action: 'close' }));
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(seen).toEqual(['closed']);
+    expect(client.status).toBe('connecting');
+    expect(ticketRequests()).toHaveLength(2);
+  });
+
+  it('goaway로 닫히면 재시도 대기 시간도 처음으로 되돌립니다 — hello를 못 받고 닫혀도', async () => {
+    const { client, ticketRequests, failTicketsWith } = createHarness();
+    failTicketsWith(500);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    failTicketsWith(null);
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(ticketRequests()).toHaveLength(4);
+
+    lastSource().dispatch('goaway', JSON.stringify({ action: 'close' }));
+    await vi.advanceTimersByTimeAsync(0);
+
+    failTicketsWith(500);
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(ticketRequests()).toHaveLength(5);
+
+    // 되돌리지 않았다면 다음 지연은 8초라서, 1초 경과 시점에는 재시도가 일어나지 않아야 합니다
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(ticketRequests()).toHaveLength(6);
+  });
+
+  it('goaway의 action이 close면 그 뒤 다시 connect한 첫 연결에서 resync를 알리지 않습니다', async () => {
+    const { client } = createHarness();
+    let resyncCount = 0;
+    client.on('resync', () => {
+      resyncCount += 1;
+    });
+
+    await openConnection(client);
+    lastSource().dispatch('goaway', JSON.stringify({ action: 'close' }));
+    await vi.advanceTimersByTimeAsync(0);
+
+    await openConnection(client);
+    expect(client.status).toBe('open');
+    // close는 세션이 끝난 것이라 다시 connect하면 새 세션입니다 — 놓친 구간이라는 게 없습니다
+    expect(resyncCount).toBe(0);
+  });
+
+  it('모르는 action은 없는 것으로 보고 재연결합니다', async () => {
+    const { client, ticketRequests } = createHarness();
+
+    await openConnection(client);
+    lastSource().dispatch(
+      'goaway',
+      JSON.stringify({ reason: 'deploy', action: 'unknown-action' })
+    );
+
+    expect(client.status).toBe('reconnecting');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(ticketRequests()).toHaveLength(2);
+  });
+});
+
+describe('disconnect', () => {
+  it('disconnect하면 연결을 닫고 closed가 됩니다', async () => {
+    const { client } = createHarness();
+
+    await openConnection(client);
+    const source = lastSource();
+    client.disconnect();
+
+    expect(source.closed).toBe(true);
+    expect(client.status).toBe('closed');
+  });
+
+  it('disconnect 후 다시 connect할 수 있고, 그 첫 연결에서는 resync를 알리지 않습니다', async () => {
+    const { client, ticketRequests } = createHarness();
+    let resyncCount = 0;
+    client.on('resync', () => {
+      resyncCount += 1;
+    });
+
+    await openConnection(client);
+    client.disconnect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    await openConnection(client);
+    expect(client.status).toBe('open');
+    expect(ticketRequests()).toHaveLength(2);
+    expect(resyncCount).toBe(0);
+  });
+
+  it('connecting 알림을 받은 리스너가 그 자리에서 disconnect해도 연결 시도가 시작되지 않습니다', async () => {
+    const { client, ticketRequests } = createHarness();
+    client.onStatus((status) => {
+      if (status === 'connecting') {
+        client.disconnect();
+      }
+    });
+
+    client.connect();
+    expect(client.status).toBe('closed');
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(ticketRequests()).toHaveLength(0);
+    expect(FakeEventSource.instances).toHaveLength(0);
+  });
+  it('open 알림을 받은 리스너가 그 자리에서 disconnect해도, 이후 다시 연결한 첫 연결을 재연결로 오인해 resync를 알리지 않습니다', async () => {
+    const { client } = createHarness();
+    let resyncCount = 0;
+    client.on('resync', () => {
+      resyncCount += 1;
+    });
+    const off = client.onStatus((status) => {
+      if (status === 'open') {
+        client.disconnect();
+      }
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    lastSource().dispatch('hello');
+    expect(client.status).toBe('closed');
+
+    off();
+    await openConnection(client);
+    expect(client.status).toBe('open');
+    expect(resyncCount).toBe(0);
+  });
+
+  it('티켓 발급 도중 disconnect하면 뒤늦게 도착한 티켓으로 연결하지 않습니다', async () => {
+    let resolveTicket: (response: Response) => void = () => {};
+    const pending = new Promise<Response>((resolve) => {
+      resolveTicket = resolve;
+    });
+    const { client } = createHarness({
+      fetch: (() => pending) as unknown as typeof globalThis.fetch,
+    });
+
+    client.connect();
+    client.disconnect();
+    resolveTicket({
+      ok: true,
+      status: 200,
+      json: async () => ({ data: { ticket: 'late' } }),
+    } as unknown as Response);
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(FakeEventSource.instances).toHaveLength(0);
+    expect(client.status).toBe('closed');
+  });
+
+  it('재시도 대기 중 disconnect하면 예약된 재시도가 취소됩니다', async () => {
+    const { client, ticketRequests, failTicketsWith } = createHarness();
+    failTicketsWith(500);
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.status).toBe('reconnecting');
+
+    client.disconnect();
+    await vi.advanceTimersByTimeAsync(120_000);
+    expect(ticketRequests()).toHaveLength(1);
+    expect(client.status).toBe('closed');
+  });
+});
+
+describe('미연결 지속(stalled)', () => {
+  const rejectingFetch = (() =>
+    Promise.reject(new Error('network'))) as unknown as typeof globalThis.fetch;
+
+  it('hello에 닿지 못한 연속 실패가 5회에 닿으면 stalled를 한 번만 알리고, 재시도는 계속됩니다', async () => {
+    const { client } = createHarness({ fetch: rejectingFetch });
+    const seen: string[] = [];
+    client.on('stalled', () => seen.push(client.status));
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(seen).toHaveLength(0);
+
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(seen).toEqual(['reconnecting']);
+
+    await vi.advanceTimersByTimeAsync(16_000);
+    expect(seen).toHaveLength(1);
+    expect(client.status).toBe('reconnecting');
+  });
+
+  it('서버가 응답한 거부(5xx)는 네트워크성이 아니라 세지 않습니다', async () => {
+    const { client, failTicketsWith } = createHarness();
+    failTicketsWith(500);
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    await vi.advanceTimersByTimeAsync(8000);
+    await vi.advanceTimersByTimeAsync(16_000);
+
+    expect(client.status).toBe('reconnecting');
+    expect(stalledCount).toBe(0);
+  });
+
+  it('서버가 응답하면(5xx) 네트워크성 연속 판정이 끊깁니다', async () => {
+    let mode: 'network' | 'server' = 'network';
+    const mixedFetch = (async () => {
+      if (mode === 'network') {
+        throw new Error('network');
+      }
+      return { ok: false, status: 500 } as Response;
+    }) as unknown as typeof globalThis.fetch;
+    const { client } = createHarness({ fetch: mixedFetch });
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+
+    mode = 'server';
+    await vi.advanceTimersByTimeAsync(8000);
+    mode = 'network';
+    await vi.advanceTimersByTimeAsync(16_000);
+    expect(stalledCount).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(stalledCount).toBe(1);
+  });
+
+  it('서버가 응답한 200의 본문 파싱 실패도 네트워크성 연속 판정을 끊습니다', async () => {
+    let mode: 'network' | 'broken-body' = 'network';
+    const mixedFetch = (async () => {
+      if (mode === 'network') {
+        throw new Error('network');
+      }
+      return {
+        ok: true,
+        status: 200,
+        json: async () => {
+          throw new Error('not json');
+        },
+      } as unknown as Response;
+    }) as unknown as typeof globalThis.fetch;
+    const { client } = createHarness({ fetch: mixedFetch });
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+
+    mode = 'broken-body';
+    await vi.advanceTimersByTimeAsync(8000);
+    mode = 'network';
+    await vi.advanceTimersByTimeAsync(16_000);
+    expect(stalledCount).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(stalledCount).toBe(1);
+  });
+
+  it('연결은 됐지만 hello 전에 끊기는 경우도 셉니다', async () => {
+    const { client } = createHarness();
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(10_000);
+    await vi.advanceTimersByTimeAsync(1000 + 10_000);
+    await vi.advanceTimersByTimeAsync(2000 + 10_000);
+    await vi.advanceTimersByTimeAsync(4000 + 10_000);
+    expect(stalledCount).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(8000 + 10_000);
+    expect(stalledCount).toBe(1);
+  });
+
+  it('stalled를 알릴 때는 전이가 끝나 있어, 핸들러가 그 자리에서 disconnect() → connect()로 재시작할 수 있습니다', async () => {
+    const { client } = createHarness({ fetch: rejectingFetch });
+    const seen: string[] = [];
+    client.on('stalled', () => {
+      seen.push(client.status);
+      client.disconnect();
+      client.connect();
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(seen).toEqual(['reconnecting']);
+
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(seen).toHaveLength(1);
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(seen).toEqual(['reconnecting', 'reconnecting']);
+  });
+
+  it('disconnect 후 다시 connect하면 판정이 새 세션으로 시작합니다', async () => {
+    const { client } = createHarness({ fetch: rejectingFetch });
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+
+    client.disconnect();
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    // 이월됐다면 직전 시도가 통산 5회째라 이미 발화했을 것입니다
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(stalledCount).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(stalledCount).toBe(1);
+  });
+
+  it('open에 도달하면 판정이 리셋되고, 수립 후 끊김 자체는 세지 않습니다', async () => {
+    let failNetwork = true;
+    let ticketCounter = 0;
+    const toggledFetch = (async () => {
+      if (failNetwork) {
+        throw new Error('network');
+      }
+      ticketCounter += 1;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ data: { ticket: `ticket-${ticketCounter}` } }),
+      } as unknown as Response;
+    }) as unknown as typeof globalThis.fetch;
+    const { client } = createHarness({ fetch: toggledFetch });
+    let stalledCount = 0;
+    client.on('stalled', () => {
+      stalledCount += 1;
+    });
+
+    client.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    expect(stalledCount).toBe(0);
+
+    failNetwork = false;
+    await vi.advanceTimersByTimeAsync(8000);
+    lastSource().dispatch('hello');
+    expect(client.status).toBe('open');
+
+    lastSource().error();
+    failNetwork = true;
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(4000);
+    // open 전 4회는 리셋됐고 수립 후 끊김도 세지 않았습니다 — 어느 쪽이든 세졌다면 이미 발화했을 것입니다
+    await vi.advanceTimersByTimeAsync(8000);
+    expect(stalledCount).toBe(0);
+
+    await vi.advanceTimersByTimeAsync(16_000);
+    expect(stalledCount).toBe(1);
+  });
+});