@sessionsight/split-testing 1.0.0 → 1.0.1

package/test/client.test.ts

@@ -1,224 +0,0 @@
-import { test, expect, beforeEach, mock } from 'bun:test';
-import {
-  getCachedConfig,
-  setCachedConfig,
-  getCachedAssignments,
-  setCachedAssignments,
-  clearCache,
-} from '../src/cache';
-import { SplitTestingClient } from '../src/client';
-import type { SplitTestConfigResponse, Assignment } from '../src/types';
-
-// Storage map injected by test/setup.ts preload
-const storage: Map<string, string> = (globalThis as any).__testStorage;
-
-// ── Helpers ────────────────────────────────────────────────────────
-
-const PROPERTY = 'prop-1';
-const VISITOR = 'visitor-1';
-
-const fakeConfigResponse: SplitTestConfigResponse = {
-  tests: [
-    {
-      key: 'hero-test',
-      id: 'test-id-1',
-      type: 'text',
-      status: 'running',
-      hashSeed: 'seed-abc',
-      trafficAllocation: 100,
-      variations: [
-        { key: 'control', weight: 50, value: 'Hello' },
-        { key: 'variant-a', weight: 50, value: 'Hey there' },
-      ],
-    },
-  ],
-  ttl: 300,
-};
-
-function makeClient(overrides: Record<string, any> = {}): SplitTestingClient {
-  return new SplitTestingClient({
-    publicApiKey: 'pk_test',
-    propertyId: PROPERTY,
-    apiUrl: 'https://api.test.com',
-    visitorId: VISITOR,
-    ...overrides,
-  });
-}
-
-beforeEach(() => {
-  storage.clear();
-});
-
-// ════════════════════════════════════════════════════════════════════
-//  Cache tests
-// ════════════════════════════════════════════════════════════════════
-
-test('setCachedConfig / getCachedConfig round trip', () => {
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-  const cached = getCachedConfig(PROPERTY);
-  expect(cached).not.toBeNull();
-  expect(cached!.data.tests[0].key).toBe('hero-test');
-  expect(typeof cached!.fetchedAt).toBe('number');
-});
-
-test('getCachedConfig returns null when nothing is stored', () => {
-  expect(getCachedConfig('nonexistent')).toBeNull();
-});
-
-test('setCachedAssignments / getCachedAssignments round trip', () => {
-  const assignments: Record<string, Assignment> = {
-    'hero-test': {
-      testKey: 'hero-test',
-      variationIndex: 1,
-      variationKey: 'variant-a',
-      value: 'Hey there',
-      type: 'text',
-      inTest: true,
-    },
-  };
-  setCachedAssignments(PROPERTY, VISITOR, assignments);
-  const cached = getCachedAssignments(PROPERTY, VISITOR);
-  expect(cached).not.toBeNull();
-  expect(cached!['hero-test'].variationKey).toBe('variant-a');
-});
-
-test('clearCache removes config and assignment entries for the property', () => {
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-  setCachedAssignments(PROPERTY, VISITOR, {
-    'hero-test': {
-      testKey: 'hero-test',
-      variationIndex: 0,
-      variationKey: 'control',
-      value: 'Hello',
-      type: 'text',
-      inTest: true,
-    },
-  });
-  expect(storage.size).toBeGreaterThan(0);
-
-  clearCache(PROPERTY);
-
-  expect(getCachedConfig(PROPERTY)).toBeNull();
-  expect(getCachedAssignments(PROPERTY, VISITOR)).toBeNull();
-});
-
-test('clearCache does not remove entries for a different property', () => {
-  setCachedConfig('prop-other', fakeConfigResponse);
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-
-  clearCache(PROPERTY);
-
-  expect(getCachedConfig(PROPERTY)).toBeNull();
-  expect(getCachedConfig('prop-other')).not.toBeNull();
-});
-
-// ════════════════════════════════════════════════════════════════════
-//  Client tests
-// ════════════════════════════════════════════════════════════════════
-
-test('get() returns default value before init', () => {
-  const client = makeClient();
-  expect(client.get('hero-test', 'fallback')).toBe('fallback');
-});
-
-test('get() returns cached assignment after init with pre-cached config', async () => {
-  // Pre-populate cache so no fetch is needed
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-
-  const client = makeClient({ maxAge: 999_999_999, staleTTL: 999_999_999 });
-  await client.init();
-
-  const value = client.get('hero-test', 'fallback');
-  // Should be one of the variation values, not the fallback
-  expect(['Hello', 'Hey there']).toContain(value);
-});
-
-test('get() fetches config from API when cache is empty', async () => {
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = mock(async (url: string | URL | Request) => {
-    const urlStr = typeof url === 'string' ? url : url.toString();
-    if (urlStr.includes('/v1/split-testing/config')) {
-      return new Response(JSON.stringify(fakeConfigResponse), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-    return new Response('{}', { status: 200 });
-  }) as any;
-
-  try {
-    const client = makeClient();
-    await client.init();
-
-    const value = client.get('hero-test', 'fallback');
-    expect(['Hello', 'Hey there']).toContain(value);
-    // Config should now be cached
-    expect(getCachedConfig(PROPERTY)).not.toBeNull();
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('trackConversion sends POST with correct payload', async () => {
-  const calls: Array<{ url: string; body: any }> = [];
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = mock(async (url: string | URL | Request, init?: RequestInit) => {
-    const urlStr = typeof url === 'string' ? url : url.toString();
-    if (init?.body) {
-      calls.push({ url: urlStr, body: JSON.parse(init.body as string) });
-    }
-    if (urlStr.includes('/v1/split-testing/config')) {
-      return new Response(JSON.stringify(fakeConfigResponse), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-    return new Response('{}', { status: 200 });
-  }) as any;
-
-  // Disable sendBeacon so it falls through to fetch
-  const origBeacon = globalThis.navigator.sendBeacon;
-  globalThis.navigator.sendBeacon = (() => false) as any;
-
-  try {
-    const client = makeClient();
-    await client.init();
-
-    client.trackConversion('goal-signup', { value: 42, currency: 'USD' });
-
-    // Find the conversion call
-    const conversionCall = calls.find((c) => c.url.includes('/convert'));
-    expect(conversionCall).toBeDefined();
-    expect(conversionCall!.body.goalId).toBe('goal-signup');
-    expect(conversionCall!.body.propertyId).toBe(PROPERTY);
-    expect(conversionCall!.body.visitorId).toBe(VISITOR);
-    expect(conversionCall!.body.value).toBe(42);
-    expect(conversionCall!.body.currency).toBe('USD');
-  } finally {
-    globalThis.fetch = originalFetch;
-    globalThis.navigator.sendBeacon = origBeacon;
-  }
-});
-
-test('getAssignments returns variation indices keyed by test key', async () => {
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-
-  const client = makeClient({ maxAge: 999_999_999, staleTTL: 999_999_999 });
-  await client.init();
-
-  const assignments = client.getAssignments();
-  expect(assignments).toHaveProperty('hero-test');
-  expect(typeof assignments['hero-test']).toBe('number');
-});
-
-test('destroy clears internal state', async () => {
-  setCachedConfig(PROPERTY, fakeConfigResponse);
-
-  const client = makeClient({ maxAge: 999_999_999, staleTTL: 999_999_999 });
-  await client.init();
-
-  client.destroy();
-
-  // After destroy, get() should return default
-  expect(client.get('hero-test', 'fallback')).toBe('fallback');
-});

package/test/hash.test.ts

@@ -1,85 +0,0 @@
-import { test, expect } from 'bun:test';
-import { splitTestHash, assignVariation } from '../src/hash';
-
-test('splitTestHash returns consistent results', () => {
-  const h1 = splitTestHash('seed-abc', 'visitor-123');
-  const h2 = splitTestHash('seed-abc', 'visitor-123');
-  expect(h1).toBe(h2);
-});
-
-test('splitTestHash returns values in 0-9999', () => {
-  for (let i = 0; i < 100; i++) {
-    const h = splitTestHash(`seed-${i}`, `visitor-${i}`);
-    expect(h).toBeGreaterThanOrEqual(0);
-    expect(h).toBeLessThan(10000);
-  }
-});
-
-test('splitTestHash produces different values for different visitors', () => {
-  const h1 = splitTestHash('seed', 'visitor-1');
-  const h2 = splitTestHash('seed', 'visitor-2');
-  expect(h1).not.toBe(h2);
-});
-
-test('splitTestHash produces different values for different seeds', () => {
-  const h1 = splitTestHash('seed-a', 'visitor');
-  const h2 = splitTestHash('seed-b', 'visitor');
-  expect(h1).not.toBe(h2);
-});
-
-test('assignVariation puts visitor in test when within traffic allocation', () => {
-  const result = assignVariation(500, 100, [
-    { key: 'control', weight: 50 },
-    { key: 'variant-a', weight: 50 },
-  ]);
-  expect(result.inTest).toBe(true);
-});
-
-test('assignVariation excludes visitor when outside traffic allocation', () => {
-  const result = assignVariation(9500, 50, [
-    { key: 'control', weight: 50 },
-    { key: 'variant-a', weight: 50 },
-  ]);
-  expect(result.inTest).toBe(false);
-  expect(result.variationIndex).toBe(0); // defaults to control
-});
-
-test('assignVariation distributes evenly with equal weights', () => {
-  const counts = [0, 0];
-  for (let i = 0; i < 10000; i++) {
-    const result = assignVariation(i, 100, [
-      { key: 'control', weight: 50 },
-      { key: 'variant-a', weight: 50 },
-    ]);
-    counts[result.variationIndex]!++;
-  }
-  // Should be roughly 50/50
-  expect(counts[0]).toBeGreaterThan(4000);
-  expect(counts[0]).toBeLessThan(6000);
-  expect(counts[1]).toBeGreaterThan(4000);
-  expect(counts[1]).toBeLessThan(6000);
-});
-
-test('assignVariation respects unequal weights', () => {
-  const counts = [0, 0, 0];
-  for (let i = 0; i < 10000; i++) {
-    const result = assignVariation(i, 100, [
-      { key: 'control', weight: 70 },
-      { key: 'variant-a', weight: 20 },
-      { key: 'variant-b', weight: 10 },
-    ]);
-    counts[result.variationIndex]!++;
-  }
-  // control ~70%, variant-a ~20%, variant-b ~10%
-  expect(counts[0]).toBeGreaterThan(6000);
-  expect(counts[1]).toBeGreaterThan(1000);
-  expect(counts[2]).toBeGreaterThan(500);
-});
-
-test('assignVariation handles zero traffic allocation', () => {
-  const result = assignVariation(500, 0, [
-    { key: 'control', weight: 50 },
-    { key: 'variant-a', weight: 50 },
-  ]);
-  expect(result.inTest).toBe(false);
-});

package/test/setup.ts

@@ -1,21 +0,0 @@
-// Preload: set up browser globals before any module evaluates canUseStorage
-
-const storage = new Map<string, string>();
-globalThis.localStorage = {
-  getItem: (key: string) => storage.get(key) ?? null,
-  setItem: (key: string, value: string) => { storage.set(key, value); },
-  removeItem: (key: string) => { storage.delete(key); },
-  clear: () => storage.clear(),
-  get length() { return storage.size; },
-  key: (i: number) => [...storage.keys()][i] ?? null,
-} as any;
-
-globalThis.window = globalThis as any;
-globalThis.document = {
-  createElement: () => ({ id: '', textContent: '', remove() {} }),
-  head: { appendChild() {} },
-} as any;
-globalThis.navigator = { sendBeacon: () => true } as any;
-
-// Export storage so tests can access it for clearing
-(globalThis as any).__testStorage = storage;

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "declaration": true,
-    "noEmit": false,
-    "rootDir": "./src",
-    "lib": ["ES2022", "DOM"],
-    "module": "ESNext",
-    "moduleResolution": "bundler"
-  },
-  "include": ["src/**/*.ts"]
-}