@goliapkg/sentori-react-native 4.0.0 → 5.1.0

package/src/__tests__/report-security.test.ts

@@ -1,106 +0,0 @@
-// v1.1 chunk S2 — reportSecurity + reportPinMismatch round-trip.
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  mock,
-} from 'bun:test';
-
-import { __resetForTests as resetConfig, setConfig } from '../config';
-import { __resetInstallIdForTests, __setInstallIdForTests } from '../install-id';
-import { setUser } from '../capture';
-import { reportPinMismatch, reportSecurity } from '../report-security';
-
-const originalFetch = globalThis.fetch;
-
-describe('reportSecurity', () => {
-  beforeEach(() => {
-    resetConfig();
-    __resetInstallIdForTests();
-    setConfig({
-      token: 'st_pk_test',
-      release: 'app@1.0.0+1',
-      environment: 'test',
-      ingestUrl: 'http://localhost:8080',
-      enabled: true,
-    });
-    setUser({ id: 'u_demo' });
-    __setInstallIdForTests('install-abc');
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    setUser(null);
-  });
-
-  it('posts the report envelope and returns the server id', async () => {
-    const calls: { body: string; url: string }[] = [];
-    globalThis.fetch = mock(async (url: unknown, init: unknown) => {
-      calls.push({
-        body: String((init as { body?: unknown })?.body ?? ''),
-        url: String(url),
-      });
-      return new Response(JSON.stringify({ id: 'sec-1' }), { status: 202 });
-    }) as unknown as typeof fetch;
-
-    const id = await reportSecurity('root.detected', { detector: 'rootbeer' });
-    expect(id).toBe('sec-1');
-    expect(calls.length).toBe(1);
-    expect(calls[0].url).toBe('http://localhost:8080/v1/security:report');
-    const parsed = JSON.parse(calls[0].body) as {
-      data: Record<string, unknown>;
-      installId: string;
-      kind: string;
-      release: string;
-      userId: string;
-    };
-    expect(parsed.kind).toBe('root.detected');
-    expect(parsed.data.detector).toBe('rootbeer');
-    expect(parsed.installId).toBe('install-abc');
-    expect(parsed.userId).toBe('u_demo');
-    expect(parsed.release).toBe('app@1.0.0+1');
-  });
-
-  it('reportPinMismatch flattens to pin.mismatch with serverName', async () => {
-    const calls: { body: string }[] = [];
-    globalThis.fetch = mock(async (_url: unknown, init: unknown) => {
-      calls.push({ body: String((init as { body?: unknown })?.body ?? '') });
-      return new Response(JSON.stringify({ id: 'sec-2' }), { status: 202 });
-    }) as unknown as typeof fetch;
-
-    const id = await reportPinMismatch({
-      expected: 'sha256/AAAA',
-      observed: 'sha256/BBBB',
-      serverName: 'api.example.com',
-    });
-    expect(id).toBe('sec-2');
-    const parsed = JSON.parse(calls[0].body) as {
-      data: { expected: string; observed: string };
-      kind: string;
-      serverName: string;
-    };
-    expect(parsed.kind).toBe('pin.mismatch');
-    expect(parsed.serverName).toBe('api.example.com');
-    expect(parsed.data.expected).toBe('sha256/AAAA');
-    expect(parsed.data.observed).toBe('sha256/BBBB');
-  });
-
-  it('returns null on transport failure rather than throwing', async () => {
-    globalThis.fetch = mock(async () => {
-      throw new Error('offline');
-    }) as unknown as typeof fetch;
-
-    const id = await reportSecurity('arbitrary.kind');
-    expect(id).toBe(null);
-  });
-
-  it('drops bad inputs silently', async () => {
-    const id1 = await reportSecurity('');
-    const id2 = await reportPinMismatch({ expected: 'a', observed: 'b', serverName: '' });
-    expect(id1).toBe(null);
-    expect(id2).toBe(null);
-  });
-});

package/src/__tests__/runtime-metrics-instruments.test.ts

@@ -1,109 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test';
-
-import {
-  __peekRuntimeMetricsSize,
-  __resetRuntimeMetricsForTests,
-  drainRuntimeMetricsForFlush,
-} from '@goliapkg/sentori-core';
-
-import {
-  __forceEmitFpsForTests,
-  __pushSampleForTests,
-  __resetFpsInstrumentForTests,
-  startFpsInstrument,
-  stopFpsInstrument,
-} from '../runtime-metrics-fps';
-import {
-  __forceHeapTickForTests,
-  __peekHeapInstrumentState,
-  startHeapInstrument,
-  stopHeapInstrument,
-} from '../runtime-metrics-heap';
-
-beforeEach(() => {
-  __resetRuntimeMetricsForTests();
-  __resetFpsInstrumentForTests();
-});
-
-afterEach(() => {
-  stopFpsInstrument();
-  stopHeapInstrument();
-});
-
-test('fps: pushes p50 + p95 emits into the runtime metrics ring', () => {
-  // 300 samples at a steady 16.67 ms cadence ≈ 60 fps.
-  for (let i = 0; i < 300; i++) {
-    __pushSampleForTests(16.67);
-  }
-  __forceEmitFpsForTests();
-
-  const drained = drainRuntimeMetricsForFlush();
-  expect(drained.length).toBe(2);
-  const names = drained.map((m) => m.name).sort();
-  expect(names).toEqual(['runtime.fps.p50', 'runtime.fps.p95']);
-  // Both should land near 60 fps.
-  const p50 = drained.find((m) => m.name === 'runtime.fps.p50')!;
-  expect(p50.value).toBeGreaterThanOrEqual(58);
-  expect(p50.value).toBeLessThanOrEqual(62);
-});
-
-test('fps: mixed-cadence run separates p50 from p95 sensibly', () => {
-  // 270 fast frames (60 fps) + 30 stutters (30 fps). p95 should
-  // land at the stutter zone.
-  for (let i = 0; i < 270; i++) __pushSampleForTests(16.67);
-  for (let i = 0; i < 30; i++) __pushSampleForTests(33.33);
-  __forceEmitFpsForTests();
-
-  const drained = drainRuntimeMetricsForFlush();
-  const p50 = drained.find((m) => m.name === 'runtime.fps.p50')!.value;
-  const p95 = drained.find((m) => m.name === 'runtime.fps.p95')!.value;
-  // p50 stays at the smooth-frame zone.
-  expect(p50).toBeGreaterThanOrEqual(58);
-  // p95 (worst-95th of Δt → slowest 5%) should drop into the
-  // 30 fps zone.
-  expect(p95).toBeLessThanOrEqual(35);
-});
-
-test('fps: start is idempotent — second call is a no-op', () => {
-  startFpsInstrument();
-  // Calling start twice mustn't spin up a second rAF loop. We
-  // don't directly observe that here (no two-loop probe), but
-  // we assert start doesn't throw + state stays running once.
-  expect(() => startFpsInstrument()).not.toThrow();
-  stopFpsInstrument();
-});
-
-test('heap: start is a no-op on hosts without performance.memory', () => {
-  // The default test runtime (bun) doesn't expose
-  // performance.memory, so start should silently skip and
-  // never schedule a timer.
-  startHeapInstrument();
-  expect(__peekHeapInstrumentState().running).toBe(false);
-});
-
-test('heap: force tick is a no-op on hosts without performance.memory', () => {
-  __forceHeapTickForTests();
-  // No metric should land in the ring.
-  expect(__peekRuntimeMetricsSize()).toBe(0);
-});
-
-test('heap: emits when performance.memory is shimmed', () => {
-  // Shim performance.memory so the read path exercises.
-  const g = globalThis as {
-    performance?: { memory?: { usedJSHeapSize?: number; totalJSHeapSize?: number } };
-  };
-  const before = g.performance;
-  g.performance = {
-    ...(before ?? {}),
-    memory: { usedJSHeapSize: 12_345_678, totalJSHeapSize: 23_456_789 },
-  };
-  try {
-    __forceHeapTickForTests();
-    const drained = drainRuntimeMetricsForFlush();
-    const names = drained.map((m) => m.name).sort();
-    expect(names).toEqual(['runtime.heap.total_bytes', 'runtime.heap.used_bytes']);
-    expect(drained.find((m) => m.name === 'runtime.heap.used_bytes')!.value).toBe(12_345_678);
-  } finally {
-    g.performance = before;
-  }
-});

package/src/__tests__/runtime-metrics-network.test.ts

@@ -1,78 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test';
-
-import {
-  __resetRuntimeMetricsForTests,
-  drainRuntimeMetricsForFlush,
-} from '@goliapkg/sentori-core';
-
-import {
-  __forceNetworkEmitForTests,
-  __peekNetworkCountersForTests,
-  __resetNetworkBytesForTests,
-  estimateRequestBytes,
-  estimateResponseBytes,
-  recordNetworkBytes,
-} from '../runtime-metrics-network';
-
-beforeEach(() => {
-  __resetRuntimeMetricsForTests();
-  __resetNetworkBytesForTests();
-});
-
-afterEach(() => __resetNetworkBytesForTests());
-
-test('recordNetworkBytes: cumulates sent + received separately', () => {
-  recordNetworkBytes(100, 200);
-  recordNetworkBytes(50, 0);
-  recordNetworkBytes(0, 25);
-  const { sent, received } = __peekNetworkCountersForTests();
-  expect(sent).toBe(150);
-  expect(received).toBe(225);
-});
-
-test('force emit: flushes both counters into the ring + resets', () => {
-  recordNetworkBytes(1234, 5678);
-  __forceNetworkEmitForTests();
-
-  const drained = drainRuntimeMetricsForFlush();
-  expect(drained.length).toBe(2);
-  const names = drained.map((m) => m.name).sort();
-  expect(names).toEqual(['runtime.network.bytes_received', 'runtime.network.bytes_sent']);
-  expect(drained.find((m) => m.name === 'runtime.network.bytes_sent')!.value).toBe(1234);
-  expect(drained.find((m) => m.name === 'runtime.network.bytes_received')!.value).toBe(5678);
-
-  const { sent, received } = __peekNetworkCountersForTests();
-  expect(sent).toBe(0);
-  expect(received).toBe(0);
-});
-
-test('force emit: skips zero counters (no empty metric emit)', () => {
-  __forceNetworkEmitForTests();
-  expect(drainRuntimeMetricsForFlush().length).toBe(0);
-});
-
-test('estimateRequestBytes: handles string body', () => {
-  expect(estimateRequestBytes({ body: 'hello world' })).toBe(11);
-  expect(estimateRequestBytes()).toBe(0);
-  expect(estimateRequestBytes({})).toBe(0);
-});
-
-test('estimateRequestBytes: reads byteLength from ArrayBuffer-like body', () => {
-  const buf = new Uint8Array([1, 2, 3, 4, 5]);
-  expect(estimateRequestBytes({ body: buf })).toBe(5);
-});
-
-test('estimateResponseBytes: parses content-length header', () => {
-  const h = new Headers({ 'content-length': '1024' });
-  expect(estimateResponseBytes(h)).toBe(1024);
-});
-
-test('estimateResponseBytes: returns 0 when header missing (chunked / stripped)', () => {
-  expect(estimateResponseBytes(new Headers())).toBe(0);
-  expect(estimateResponseBytes(null)).toBe(0);
-});
-
-test('estimateResponseBytes: returns 0 on unparseable header (undercount-safe)', () => {
-  const h = new Headers({ 'content-length': 'nope' });
-  expect(estimateResponseBytes(h)).toBe(0);
-});

package/src/__tests__/sample-profiler.test.ts

@@ -1,59 +0,0 @@
-// v1.1 #4 升级 — JS sample profiler unit tests.
-
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import { clearSpans, drainSpans } from '@goliapkg/sentori-core';
-
-import {
-  __resetSampleProfilerForTests,
-  startSampleProfiler,
-  stopSampleProfiler,
-} from '../sample-profiler';
-
-afterEach(() => {
-  __resetSampleProfilerForTests();
-  clearSpans();
-});
-
-describe('sample-profiler', () => {
-  test('start with enabled=false is a no-op', () => {
-    startSampleProfiler({ enabled: false });
-    stopSampleProfiler();
-    expect(drainSpans().length).toBe(0);
-  });
-
-  test('double start is idempotent (second call ignored)', () => {
-    startSampleProfiler({ enabled: true, sampleMs: 30, flushMs: 5_000 });
-    // A second start while the timer is live must not spin a second
-    // interval — would double-count every sample.
-    startSampleProfiler({ enabled: true, sampleMs: 30, flushMs: 5_000 });
-    stopSampleProfiler();
-  });
-
-  test('stop clears state cleanly', async () => {
-    startSampleProfiler({ enabled: true, sampleMs: 30, flushMs: 5_000 });
-    // Let a few sampleTicks happen.
-    await new Promise((r) => setTimeout(r, 120));
-    stopSampleProfiler();
-    // After stop, no further span should be emitted even past flushMs.
-    await new Promise((r) => setTimeout(r, 80));
-    // (Bun timers aren't faked here, so we don't wait the full flush
-    // window; we just confirm stop returns cleanly and __reset works.)
-    __resetSampleProfilerForTests();
-    expect(true).toBe(true);
-  });
-
-  test('sample interval floor — sampleMs < 20 clamped up to 20', () => {
-    // Internal: profile.duration_ms tag uses the *effective* window
-    // length so we can't directly observe the chosen sampleMs, but we
-    // *can* assert start doesn't throw with an absurd request, since
-    // the clamp protects against pathological CPU burn.
-    startSampleProfiler({ enabled: true, sampleMs: 1, flushMs: 5_000 });
-    stopSampleProfiler();
-  });
-
-  test('flush interval floor — flushMs < 5000 clamped up to 5000', () => {
-    startSampleProfiler({ enabled: true, sampleMs: 30, flushMs: 100 });
-    stopSampleProfiler();
-  });
-});

package/src/__tests__/stack.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-
-import { parseStack } from '../stack';
-
-describe('parseStack', () => {
-  it('returns [] for undefined', () => {
-    expect(parseStack(undefined)).toEqual([]);
-  });
-
-  it('returns [] for empty string', () => {
-    expect(parseStack('')).toEqual([]);
-  });
-
-  it('parses V8/Hermes-style frames', () => {
-    const stack = `TypeError: Cannot read property 'foo' of undefined
-    at handleSubmit (src/screens/Checkout.tsx:42:10)
-    at onPress (src/components/Button.tsx:15:5)`;
-    const frames = parseStack(stack);
-    expect(frames).toHaveLength(2);
-    // Phase 21: core's parseStack also populates absolutePath, so we
-    // match the subset of fields rather than full equality.
-    expect(frames[0]).toMatchObject({
-      column: 10,
-      file: 'src/screens/Checkout.tsx',
-      function: 'handleSubmit',
-      inApp: true,
-      line: 42,
-    });
-    expect(frames[1]?.function).toBe('onPress');
-  });
-
-  it('marks node_modules frames as not inApp', () => {
-    const stack = `Error
-    at vendorFn (node_modules/react-native/Libraries/Foo.js:1:1)`;
-    const frames = parseStack(stack);
-    expect(frames[0]?.inApp).toBe(false);
-  });
-
-  it('marks http(s) urls as not inApp', () => {
-    const stack = `Error
-    at someFn (https://cdn.example.com/bundle.js:1:1)`;
-    const frames = parseStack(stack);
-    expect(frames[0]?.inApp).toBe(false);
-  });
-});

package/src/__tests__/state-snapshots.test.ts

@@ -1,119 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import {
-  __resetStateSnapshotsForTests,
-  bindState,
-  getStateSnapshots,
-  recordState,
-  shallowDiff,
-  unbindState,
-} from '../state-snapshots';
-
-afterEach(() => {
-  __resetStateSnapshotsForTests();
-});
-
-describe('shallowDiff', () => {
-  test('emits only changed top-level keys', () => {
-    const a = { foo: 1, bar: 2 };
-    const b = { bar: 2, foo: 3 };
-    expect(shallowDiff(a, b)).toEqual({ foo: 3 });
-  });
-
-  test('emits new keys from next', () => {
-    expect(shallowDiff({ a: 1 }, { a: 1, b: 2 })).toEqual({ b: 2 });
-  });
-
-  test('treats deletion as undefined', () => {
-    expect(shallowDiff({ a: 1, b: 2 }, { a: 1 })).toEqual({ b: undefined });
-  });
-
-  test('no change returns empty object', () => {
-    expect(shallowDiff({ a: 1 }, { a: 1 })).toEqual({});
-  });
-
-  test('non-object prev → full clone of next', () => {
-    expect(shallowDiff(undefined, { a: 1 })).toEqual({ a: 1 });
-  });
-});
-
-describe('recordState', () => {
-  test('appends snapshot with default source=manual', () => {
-    recordState({ cart: 3 });
-    const snaps = getStateSnapshots();
-    expect(snaps.length).toBe(1);
-    expect(snaps[0]!.source).toBe('manual');
-    expect(snaps[0]!.diff).toEqual({ cart: 3 });
-  });
-
-  test('caps at 50 snapshots (ring buffer)', () => {
-    for (let i = 0; i < 60; i++) recordState({ n: i });
-    expect(getStateSnapshots().length).toBe(50);
-    // oldest 10 dropped; first kept entry has n=10
-    expect(getStateSnapshots()[0]!.diff).toEqual({ n: 10 });
-  });
-});
-
-describe('bindState', () => {
-  test('subscribes to a redux-like store and records diffs', () => {
-    let state: { count: number } = { count: 0 };
-    const listeners: (() => void)[] = [];
-    const store = {
-      getState: () => state,
-      subscribe: (cb: () => void) => {
-        listeners.push(cb);
-        return () => {
-          const i = listeners.indexOf(cb);
-          if (i >= 0) listeners.splice(i, 1);
-        };
-      },
-    };
-    bindState({ redux: store });
-    state = { count: 1 };
-    listeners.forEach((l) => l());
-    state = { count: 2 };
-    listeners.forEach((l) => l());
-
-    const snaps = getStateSnapshots();
-    expect(snaps.length).toBe(2);
-    expect(snaps[0]!.diff).toEqual({ count: 1 });
-    expect(snaps[1]!.diff).toEqual({ count: 2 });
-    expect(snaps[0]!.source).toBe('redux');
-  });
-
-  test('unbindState stops recording', () => {
-    let state: { v: number } = { v: 0 };
-    const listeners: (() => void)[] = [];
-    const store = {
-      getState: () => state,
-      subscribe: (cb: () => void) => {
-        listeners.push(cb);
-        return () => listeners.splice(listeners.indexOf(cb), 1);
-      },
-    };
-    bindState({ redux: store });
-    state = { v: 1 };
-    listeners.forEach((l) => l());
-    unbindState();
-    state = { v: 2 };
-    listeners.forEach((l) => l());
-
-    expect(getStateSnapshots().length).toBe(1);
-  });
-
-  test('custom stores produce labeled snapshots', () => {
-    let auth = { user: null };
-    const listeners: (() => void)[] = [];
-    const store = {
-      getState: () => auth,
-      subscribe: (cb: () => void) => {
-        listeners.push(cb);
-        return () => listeners.splice(listeners.indexOf(cb), 1);
-      },
-    };
-    bindState({ custom: { auth: store } });
-    auth = { user: 'alice' as never };
-    listeners.forEach((l) => l());
-    expect(getStateSnapshots()[0]!.source).toBe('auth');
-  });
-});