@goliapkg/sentori-react-native 4.0.0 → 5.1.0

package/src/__tests__/control-channel.test.ts

@@ -1,111 +0,0 @@
-// v1.1 +S7 升级 — control channel unit tests.
-
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
-
-import { setConfig, __resetForTests as resetConfig } from '../config';
-import {
-  __resetControlChannelForTests,
-  isLiveMode,
-  startControlChannel,
-  stopControlChannel,
-} from '../control-channel';
-import { setUser } from '../capture';
-
-const originalFetch = globalThis.fetch;
-
-beforeEach(() => {
-  resetConfig();
-  __resetControlChannelForTests();
-  setConfig({
-    token: 'st_pk_test',
-    release: 'app@1.0.0+1',
-    environment: 'test',
-    ingestUrl: 'http://localhost:8080',
-    enabled: true,
-    screenshotsEnabled: false,
-    errorSampleRate: null,
-    traceSampleRate: null,
-    sessionTrailEnabled: false,
-  });
-  setUser({ id: 'u-1' });
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  __resetControlChannelForTests();
-});
-
-describe('control-channel', () => {
-  test('isLiveMode() is false by default', () => {
-    expect(isLiveMode()).toBe(false);
-  });
-
-  test('start → poll → server says liveMode:true → isLiveMode flips on', async () => {
-    globalThis.fetch = mock(async () =>
-      new Response(JSON.stringify({ liveMode: true, ttlMs: 60_000 }), {
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      }),
-    ) as typeof fetch;
-
-    startControlChannel();
-    // The initial pollOnce is awaited via void, so give it a microtask.
-    await new Promise((r) => setTimeout(r, 30));
-    expect(isLiveMode()).toBe(true);
-    stopControlChannel();
-  });
-
-  test('server says liveMode:false → isLiveMode stays false', async () => {
-    globalThis.fetch = mock(async () =>
-      new Response(JSON.stringify({ liveMode: false, ttlMs: 0 }), {
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      }),
-    ) as typeof fetch;
-
-    startControlChannel();
-    await new Promise((r) => setTimeout(r, 30));
-    expect(isLiveMode()).toBe(false);
-    stopControlChannel();
-  });
-
-  test('network failure leaves prior state (no throw on poll error)', async () => {
-    globalThis.fetch = mock(async () => {
-      throw new Error('econn');
-    }) as typeof fetch;
-    startControlChannel();
-    await new Promise((r) => setTimeout(r, 30));
-    // Should not have thrown; isLiveMode stays false.
-    expect(isLiveMode()).toBe(false);
-    stopControlChannel();
-  });
-
-  test('server-reported ttlMs is capped at 15min defence-in-depth', async () => {
-    // 24h ttl from server — caller should cap.
-    globalThis.fetch = mock(async () =>
-      new Response(JSON.stringify({ liveMode: true, ttlMs: 24 * 60 * 60_000 }), {
-        status: 200,
-        headers: { 'content-type': 'application/json' },
-      }),
-    ) as typeof fetch;
-    startControlChannel();
-    await new Promise((r) => setTimeout(r, 30));
-    // We don't expose _liveModeUntil directly, but we can at least
-    // confirm liveMode flipped on without runaway state.
-    expect(isLiveMode()).toBe(true);
-    stopControlChannel();
-  });
-
-  test('without setUser, liveMode stays off (no key to poll)', async () => {
-    setUser(undefined);
-    globalThis.fetch = mock(async () =>
-      new Response(JSON.stringify({ liveMode: true, ttlMs: 60_000 }), {
-        status: 200,
-      }),
-    ) as typeof fetch;
-    startControlChannel();
-    await new Promise((r) => setTimeout(r, 30));
-    expect(isLiveMode()).toBe(false);
-    stopControlChannel();
-  });
-});

package/src/__tests__/install-id.test.ts

@@ -1,60 +0,0 @@
-// v1.1 chunk S1 — install-id module persistence + race-safety.
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-} from 'bun:test';
-
-import {
-  __resetInstallIdForTests,
-  getInstallId,
-  peekInstallId,
-} from '../install-id';
-
-describe('install-id', () => {
-  beforeEach(() => {
-    __resetInstallIdForTests();
-  });
-
-  afterEach(() => {
-    __resetInstallIdForTests();
-  });
-
-  it('peekInstallId is null before first resolve', () => {
-    expect(peekInstallId()).toBe(null);
-  });
-
-  it('getInstallId generates a stable id and caches it', async () => {
-    const first = await getInstallId();
-    expect(typeof first).toBe('string');
-    expect(first.length).toBeGreaterThan(10);
-    // sync peek after resolve returns the same value
-    expect(peekInstallId()).toBe(first);
-    // second call returns the cached value
-    expect(await getInstallId()).toBe(first);
-  });
-
-  it('concurrent callers share the same resolve promise', async () => {
-    const [a, b, c] = await Promise.all([
-      getInstallId(),
-      getInstallId(),
-      getInstallId(),
-    ]);
-    expect(a).toBe(b);
-    expect(b).toBe(c);
-  });
-
-  it('produces UUIDv7 shape (variant + version nibble)', async () => {
-    const id = await getInstallId();
-    // RFC 4122 dash positions
-    expect(id[8]).toBe('-');
-    expect(id[13]).toBe('-');
-    expect(id[14]).toBe('7'); // version
-    expect(id[18]).toBe('-');
-    // variant nibble is 8|9|a|b (high 2 bits = 10)
-    expect(['8', '9', 'a', 'b']).toContain(id[19]);
-  });
-});

package/src/__tests__/long-task-monitor.test.ts

@@ -1,59 +0,0 @@
-// v0.9.6 #4 — long-task monitor unit tests.
-
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import { clearSpans, drainSpans } from '@goliapkg/sentori-core';
-
-import {
-  __resetLongTaskMonitorForTests,
-  startLongTaskMonitor,
-  stopLongTaskMonitor,
-} from '../long-task-monitor';
-
-afterEach(() => {
-  __resetLongTaskMonitorForTests();
-  clearSpans();
-});
-
-describe('long-task-monitor', () => {
-  test('disabled is a no-op', () => {
-    startLongTaskMonitor({ enabled: false });
-    expect(drainSpans().length).toBe(0);
-  });
-
-  test('double-start is idempotent', () => {
-    startLongTaskMonitor({ enabled: true });
-    // Second call must not register a parallel interval — would
-    // double-count every tick.
-    startLongTaskMonitor({ enabled: true });
-    stopLongTaskMonitor();
-  });
-
-  test('synthetic long task crosses threshold and emits a span', async () => {
-    // 80ms threshold so we don't need a 200ms+ block in the test.
-    startLongTaskMonitor({ enabled: true, thresholdMs: 80 });
-    // Busy-block the JS thread for ~150ms; the next tick will see
-    // elapsed >> tickInterval and emit a longtask span.
-    const t0 = Date.now();
-    while (Date.now() - t0 < 150) {
-      // burn — no setTimeout, the thread must actually be busy.
-    }
-    // Let the next 50ms tick fire.
-    await new Promise((r) => setTimeout(r, 80));
-    const spans = drainSpans();
-    const longtask = spans.find((s) => s.op === 'sentori.longtask');
-    expect(longtask).toBeDefined();
-    expect(longtask?.tags?.['profile.kind']).toBe('longtask');
-    stopLongTaskMonitor();
-  });
-
-  test('sub-threshold ticks do not emit', async () => {
-    startLongTaskMonitor({ enabled: true, thresholdMs: 500 });
-    // Don't block — let normal idle ticks happen.
-    await new Promise((r) => setTimeout(r, 200));
-    const spans = drainSpans();
-    const longtasks = spans.filter((s) => s.op === 'sentori.longtask');
-    expect(longtasks.length).toBe(0);
-    stopLongTaskMonitor();
-  });
-});

package/src/__tests__/measure.test.ts

@@ -1,45 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import { clearSpans, drainSpans } from '@goliapkg/sentori-core';
-
-import { measureFn } from '../measure';
-
-afterEach(() => {
-  clearSpans();
-});
-
-describe('measureFn', () => {
-  test('runs fn, returns result, emits an ok span', async () => {
-    const r = await measureFn('addToCart', async () => 42);
-    expect(r).toBe(42);
-    const spans = drainSpans();
-    expect(spans.length).toBe(1);
-    expect(spans[0]!.op).toBe('sentori.measureFn');
-    expect(spans[0]!.name).toBe('addToCart');
-    expect(spans[0]!.status).toBe('ok');
-  });
-
-  test('supports sync fn too (Promise.resolve hides the difference)', async () => {
-    const r = await measureFn('syncJob', () => 'hello');
-    expect(r).toBe('hello');
-    expect(drainSpans()[0]!.status).toBe('ok');
-  });
-
-  test('propagates thrown errors and marks span as error', async () => {
-    await expect(
-      measureFn('failing', async () => {
-        throw new Error('nope');
-      }),
-    ).rejects.toThrow('nope');
-    const spans = drainSpans();
-    expect(spans.length).toBe(1);
-    expect(spans[0]!.status).toBe('error');
-    expect(spans[0]!.tags['error.message']).toBe('nope');
-  });
-
-  test('passes through caller tags', async () => {
-    await measureFn('withTags', async () => 'ok', { tags: { region: 'jp' } });
-    const spans = drainSpans();
-    expect(spans[0]!.tags.region).toBe('jp');
-  });
-});

package/src/__tests__/navigation.test.ts

@@ -1,175 +0,0 @@
-import {
-  __resetTraceContextForTests,
-  __useFallbackTraceContextForTests,
-  activeSpan,
-  clearSpans,
-  drainSpans,
-  setActiveSpan,
-  startSpan,
-} from '@goliapkg/sentori-core';
-import { afterAll, afterEach, beforeEach, describe, expect, test } from 'bun:test';
-
-import { type NavigationRefLike, useTraceNavigation } from '../navigation';
-
-// We test the hook without a React renderer (sdk/react-native has no
-// react-test-renderer / @testing-library dev-dep). `harness` mirrors
-// the hook's effect body 1:1 — when production changes, this changes
-// too. The point is to verify the observable contract: spans pushed
-// in the right order + the open screen span left active.
-
-class FakeNav implements NavigationRefLike {
-  private listeners: Array<() => void> = [];
-  private route: { name: string } | undefined;
-
-  setInitialRoute(name: string): void {
-    this.route = { name };
-  }
-  addListener(_event: 'state', listener: () => void): () => void {
-    this.listeners.push(listener);
-    return () => {
-      this.listeners = this.listeners.filter((l) => l !== listener);
-    };
-  }
-  getCurrentRoute(): { name: string } | undefined {
-    return this.route;
-  }
-  go(name: string): void {
-    this.route = { name };
-    this.listeners.forEach((l) => l());
-  }
-}
-
-function harness(navigationRef: NavigationRefLike): () => void {
-  let lastRoute: null | string = null;
-  let openSpan: ReturnType<typeof startSpan> | null = null;
-
-  const openScreenSpan = (from: null | string, to: string) => {
-    const span = startSpan('react.navigation', {
-      name: from ? `${from} → ${to}` : to,
-      parent: null,
-      tags: { 'nav.from': from ?? '', 'nav.to': to },
-    });
-    openSpan = span;
-    setActiveSpan(span);
-    lastRoute = to;
-  };
-
-  const initial = navigationRef.getCurrentRoute()?.name ?? null;
-  if (initial !== null) openScreenSpan(null, initial);
-  else lastRoute = null;
-
-  const unsub = navigationRef.addListener('state', () => {
-    const next = navigationRef.getCurrentRoute()?.name ?? null;
-    if (next === null || next === lastRoute) return;
-    openSpan?.finish({ status: 'ok' });
-    openScreenSpan(lastRoute, next);
-  });
-
-  return () => {
-    unsub();
-    openSpan?.finish({ status: 'ok' });
-    openSpan = null;
-    setActiveSpan(null);
-  };
-}
-
-beforeEach(() => {
-  // Navigation relies on setActiveSpan, which is a no-op on the
-  // ALS impl that bun (Node) picks. In production this runs on RN,
-  // where the fallback impl is in effect — exercise that one.
-  __useFallbackTraceContextForTests();
-  clearSpans();
-});
-afterEach(() => {
-  setActiveSpan(null);
-  clearSpans();
-});
-afterAll(() => {
-  __resetTraceContextForTests();
-});
-
-describe('useTraceNavigation', () => {
-  test('exports a hook', () => {
-    expect(typeof useTraceNavigation).toBe('function');
-  });
-
-  test('initial mount opens a span for the first screen and leaves it active', () => {
-    const nav = new FakeNav();
-    nav.setInitialRoute('Home');
-    const cleanup = harness(nav);
-
-    // span not finished yet (still on Home) → buffer empty
-    expect(drainSpans()).toHaveLength(0);
-    expect(activeSpan()).not.toBeNull();
-
-    cleanup();
-    const spans = drainSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0]?.op).toBe('react.navigation');
-    expect(spans[0]?.name).toBe('Home');
-    expect(spans[0]?.tags).toEqual({ 'nav.from': '', 'nav.to': 'Home' });
-  });
-
-  test('mount with no current route → no span, no active', () => {
-    const nav = new FakeNav(); // no initial route
-    const cleanup = harness(nav);
-    expect(activeSpan()).toBeNull();
-    cleanup();
-    expect(drainSpans()).toHaveLength(0);
-  });
-
-  test('http.client span during a screen becomes a child of the nav span', () => {
-    const nav = new FakeNav();
-    nav.setInitialRoute('Home');
-    const cleanup = harness(nav);
-    const navSpan = activeSpan()!;
-
-    // simulate the network handler opening a request span (no explicit
-    // parent → inherits the active nav span)
-    const req = startSpan('http.client', { name: 'GET /x' });
-    expect(req.parentSpanId).toBe(navSpan.spanId);
-    expect(req.traceId).toBe(navSpan.traceId);
-    req.finish({ status: 'ok' });
-
-    cleanup();
-    const spans = drainSpans();
-    const navTrace = spans.find((s) => s.op === 'react.navigation')!.traceId;
-    expect(spans.every((s) => s.traceId === navTrace)).toBe(true);
-  });
-
-  test('each screen is its own trace root (transitions do not nest)', () => {
-    const nav = new FakeNav();
-    nav.setInitialRoute('A');
-    const cleanup = harness(nav);
-    nav.go('B');
-    nav.go('C');
-    cleanup();
-
-    const spans = drainSpans().filter((s) => s.op === 'react.navigation');
-    expect(spans).toHaveLength(3);
-    expect(spans.map((s) => s.name)).toEqual(['A', 'A → B', 'B → C']);
-    expect(spans.every((s) => s.parentSpanId === null)).toBe(true);
-    expect(new Set(spans.map((s) => s.traceId)).size).toBe(3);
-  });
-
-  test('same-route state event does not open a new span', () => {
-    const nav = new FakeNav();
-    nav.setInitialRoute('Home');
-    const cleanup = harness(nav);
-    nav.go('Home');
-    cleanup();
-    expect(drainSpans().filter((s) => s.op === 'react.navigation')).toHaveLength(1);
-  });
-
-  test('cleanup finishes the open span and clears the active span', () => {
-    const nav = new FakeNav();
-    nav.setInitialRoute('Home');
-    const cleanup = harness(nav);
-    nav.go('Settings');
-    cleanup();
-
-    expect(activeSpan()).toBeNull();
-    const spans = drainSpans().filter((s) => s.op === 'react.navigation');
-    expect(spans.map((s) => s.name)).toEqual(['Home', 'Home → Settings']);
-  });
-});

package/src/__tests__/push.test.ts

@@ -1,238 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
-
-// Mock the native bridge layer only — leaves expo-modules-core / react-native
-// pristine so other test files in the same bun process aren't affected.
-
-type DrainResult = {
-  token?: string
-  error?: string
-  notifications: Array<Record<string, unknown>>
-  taps: Array<Record<string, unknown>>
-}
-
-let _drainQueue: DrainResult[] = []
-let _permissionAnswer: null | string = null
-let _registerInvocations = 0
-let _unregisterInvocations = 0
-
-mock.module('../native', () => ({
-  pushGetStatus: async () => _permissionAnswer,
-  pushRequestPermission: async () => _permissionAnswer ?? 'notDetermined',
-  pushRegister: () => {
-    _registerInvocations++
-  },
-  pushUnregister: () => {
-    _unregisterInvocations++
-  },
-  pushDrainState: async () => {
-    if (_drainQueue.length === 0) {
-      return { notifications: [], taps: [] }
-    }
-    return _drainQueue.shift()!
-  },
-}))
-
-// Mock the config getter — push reads ingest URL + bearer from here.
-// Stub ALL public exports so other test files that import named
-// exports from '../config' don't get a "Export named X not found"
-// error from the partial mock (bun mock.module replaces the whole
-// module surface, not just the named exports listed).
-let _mockConfig: { ingestUrl: string; token: string } | null = null
-mock.module('../config', () => ({
-  getConfig: () => _mockConfig,
-  isInitialized: () => _mockConfig !== null,
-  setConfig: (c: typeof _mockConfig) => {
-    _mockConfig = c
-  },
-  __resetForTests: () => {
-    _mockConfig = null
-  },
-}))
-
-import { register, unregister, getCachedIpt, __setPlatformForTests } from '../push'
-
-type FetchCall = { url: string; method: string; body?: string }
-let _fetchCalls: FetchCall[] = []
-let _fetchResponse: { status: number; body: unknown } = {
-  status: 200,
-  body: { id: 'ipt_deadbeef' },
-}
-
-const originalFetch = globalThis.fetch
-beforeEach(() => {
-  _fetchCalls = []
-  _mockConfig = { ingestUrl: 'https://ingest.test', token: 'st_test' }
-  _drainQueue = []
-  _permissionAnswer = null
-  _registerInvocations = 0
-  _unregisterInvocations = 0
-  _fetchResponse = { status: 200, body: { id: 'ipt_deadbeef' } }
-  globalThis.fetch = (async (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    _fetchCalls.push({
-      url: typeof input === 'string' ? input : input.toString(),
-      method: init?.method ?? 'GET',
-      body: typeof init?.body === 'string' ? init.body : undefined,
-    })
-    return new Response(JSON.stringify(_fetchResponse.body), {
-      status: _fetchResponse.status,
-    })
-  }) as typeof fetch
-})
-
-afterEach(() => {
-  globalThis.fetch = originalFetch
-})
-
-describe('push.register', () => {
-  it('rejects cleanly when permission is denied', async () => {
-    _permissionAnswer = 'denied'
-    await expect(register()).rejects.toThrow(/permission/i)
-    expect(_fetchCalls).toHaveLength(0)
-  })
-
-  it('rejects when the native token times out', async () => {
-    _permissionAnswer = 'granted'
-    await expect(register({ tokenTimeoutMs: 50 })).rejects.toThrow(/not received/i)
-    expect(_fetchCalls).toHaveLength(0)
-  })
-
-  it('POSTs to /v1/push/tokens with the APNs hex token and resolves to ipt', async () => {
-    _permissionAnswer = 'granted'
-    _drainQueue = [
-      { notifications: [], taps: [] },
-      { token: '0123abcdef', notifications: [], taps: [] },
-    ]
-    const result = await register({ linkHash: 'h1' })
-    expect(result.ipt).toBe('ipt_deadbeef')
-    expect(getCachedIpt()).toBe('ipt_deadbeef')
-    expect(_fetchCalls).toHaveLength(1)
-    expect(_fetchCalls[0]?.url).toContain('/v1/push/tokens')
-    expect(_fetchCalls[0]?.method).toBe('POST')
-    const body = JSON.parse(_fetchCalls[0]?.body ?? '{}')
-    expect(body.provider).toBe('apns')
-    expect(body.nativeToken).toBe('0123abcdef')
-    expect(body.linkHash).toBe('h1')
-    expect(_registerInvocations).toBe(1)
-  })
-
-  it('surfaces server failures', async () => {
-    _permissionAnswer = 'granted'
-    _drainQueue = [{ token: '00ff', notifications: [], taps: [] }]
-    _fetchResponse = { status: 503, body: { error: 'dbNotConfigured' } }
-    await expect(register()).rejects.toThrow(/503/)
-  })
-
-  it('fires onMessage for buffered notifications surfaced during waitForToken', async () => {
-    _permissionAnswer = 'granted'
-    _drainQueue = [
-      {
-        notifications: [
-          { id: 'n1', title: 'Hi', body: 'hello', userInfo: { x: 1 } },
-        ],
-        taps: [],
-      },
-      { token: 'abcd', notifications: [], taps: [] },
-    ]
-    const seen: Array<{ title?: string; body?: string }> = []
-    await register({ onMessage: (m) => seen.push(m) })
-    expect(seen).toHaveLength(1)
-    expect(seen[0]?.title).toBe('Hi')
-    expect(seen[0]?.body).toBe('hello')
-  })
-})
-
-describe('push.register — Android (FCM) branch', () => {
-  beforeEach(() => __setPlatformForTests('android'))
-  afterEach(() => __setPlatformForTests(null))
-
-  it('POSTs with provider:"fcm" and omits env on Android', async () => {
-    _permissionAnswer = 'granted'
-    _drainQueue = [{ token: 'fcm-reg-token', notifications: [], taps: [] }]
-    await register()
-    expect(_fetchCalls).toHaveLength(1)
-    const body = JSON.parse(_fetchCalls[0]?.body ?? '{}') as Record<string, unknown>
-    expect(body.provider).toBe('fcm')
-    expect(body.nativeToken).toBe('fcm-reg-token')
-    expect('env' in body).toBe(false)
-  })
-})
-
-describe('push.auto-correlate (v2.26)', () => {
-  it('writes a push breadcrumb when notification carries _sentori.msgId', async () => {
-    const { clearBreadcrumbs, getBreadcrumbs } = await import('@goliapkg/sentori-core')
-    clearBreadcrumbs()
-    _permissionAnswer = 'granted'
-    _drainQueue = [
-      {
-        notifications: [
-          {
-            body: 'a body',
-            id: 'n2',
-            title: 'A title',
-            userInfo: { _sentori: { msgId: 'send_abc123' } },
-          },
-        ],
-        taps: [],
-      },
-      { notifications: [], taps: [], token: 'abcd' },
-    ]
-    await register()
-    const crumbs = getBreadcrumbs()
-    const pushCrumb = crumbs.find((c) => c.type === 'push')
-    expect(pushCrumb).toBeDefined()
-    expect((pushCrumb?.data as Record<string, unknown>)?.msgId).toBe('send_abc123')
-    expect((pushCrumb?.data as Record<string, unknown>)?.title).toBe('A title')
-    expect((pushCrumb?.data as Record<string, unknown>)?.opened).toBe(false)
-  })
-
-  it('skips breadcrumb when payload has no _sentori.msgId', async () => {
-    const { clearBreadcrumbs, getBreadcrumbs } = await import('@goliapkg/sentori-core')
-    clearBreadcrumbs()
-    _permissionAnswer = 'granted'
-    _drainQueue = [
-      { notifications: [{ id: 'n3', title: 'No correlation' }], taps: [] },
-      { notifications: [], taps: [], token: 'abcd' },
-    ]
-    await register()
-    const crumbs = getBreadcrumbs()
-    expect(crumbs.find((c) => c.type === 'push')).toBeUndefined()
-  })
-
-  it('marks tap breadcrumb as opened:true', async () => {
-    const { clearBreadcrumbs, getBreadcrumbs } = await import('@goliapkg/sentori-core')
-    clearBreadcrumbs()
-    _permissionAnswer = 'granted'
-    _drainQueue = [
-      {
-        notifications: [],
-        taps: [{ userInfo: { _sentori: { msgId: 'send_tap' } } }],
-      },
-      { notifications: [], taps: [], token: 'abcd' },
-    ]
-    await register()
-    const pushCrumb = getBreadcrumbs().find((c) => c.type === 'push')
-    expect(pushCrumb).toBeDefined()
-    expect((pushCrumb?.data as Record<string, unknown>)?.opened).toBe(true)
-    expect((pushCrumb?.data as Record<string, unknown>)?.msgId).toBe('send_tap')
-  })
-})
-
-describe('push.unregister', () => {
-  it('DELETEs the cached ipt and clears the local state', async () => {
-    _permissionAnswer = 'granted'
-    _drainQueue = [{ token: 'feedface', notifications: [], taps: [] }]
-    await register()
-    expect(getCachedIpt()).toBe('ipt_deadbeef')
-    _fetchCalls = []
-
-    await unregister()
-    expect(_fetchCalls).toHaveLength(1)
-    expect(_fetchCalls[0]?.url).toContain('/v1/push/tokens/ipt_deadbeef')
-    expect(_fetchCalls[0]?.method).toBe('DELETE')
-    expect(getCachedIpt()).toBeNull()
-    expect(_unregisterInvocations).toBeGreaterThan(0)
-  })
-})