@forgecharts/sdk 1.1.27 → 1.1.28

package/src/trading/__tests__/TradingOverlayStore.test.ts

@@ -1,323 +0,0 @@
-/**
- * TradingOverlayStore — unit tests
- *
- * Covers:
- *   - Orders: set, upsert, remove, getByGroup
- *   - Positions: set, upsert, remove
- *   - Fills: push, getFills, getFillsByOrder
- *   - clear() resets everything
- *   - snapshot() reflects current state
- *   - onChange subscriber fires on every mutation
- *   - Both unmanaged and managed pathways can write into the same store
- *   - groupId-based linked orders coexist correctly
- *   - TP / SL / entry roles are stored verbatim
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { TradingOverlayStore } from '../TradingOverlayStore';
-import type { ChartOrder, ChartPosition, ExecutionFill } from '../tradingTypes';
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeOrder(id: string, overrides: Partial<ChartOrder> = {}): ChartOrder {
-  return {
-    id,
-    role:   'entry',
-    side:   'buy',
-    status: 'open',
-    price:  100,
-    qty:    1,
-    ...overrides,
-  };
-}
-
-function makePosition(id: string, overrides: Partial<ChartPosition> = {}): ChartPosition {
-  return {
-    id,
-    side:       'long',
-    status:     'open',
-    entryPrice: 100,
-    qty:        1,
-    ...overrides,
-  };
-}
-
-function makeFill(id: string, orderId?: string): ExecutionFill {
-  return {
-    id,
-    side:      'buy',
-    price:     100,
-    qty:       1,
-    timestamp: Date.now(),
-    ...(orderId !== undefined ? { orderId } : {}),
-  };
-}
-
-// ─── Orders ───────────────────────────────────────────────────────────────────
-
-describe('TradingOverlayStore — orders', () => {
-  let store: TradingOverlayStore;
-  beforeEach(() => { store = new TradingOverlayStore(); });
-
-  it('starts empty', () => {
-    expect(store.getOrders()).toHaveLength(0);
-  });
-
-  it('setOrders replaces the entire set', () => {
-    store.setOrders([makeOrder('a'), makeOrder('b')]);
-    expect(store.getOrders()).toHaveLength(2);
-
-    store.setOrders([makeOrder('c')]);
-    expect(store.getOrders()).toHaveLength(1);
-    expect(store.getOrders()[0]!.id).toBe('c');
-  });
-
-  it('upsertOrder inserts a new order', () => {
-    store.upsertOrder(makeOrder('o1'));
-    expect(store.getOrders()).toHaveLength(1);
-    expect(store.getOrders()[0]!.id).toBe('o1');
-  });
-
-  it('upsertOrder replaces an existing order by id', () => {
-    store.upsertOrder(makeOrder('o1', { price: 100 }));
-    store.upsertOrder(makeOrder('o1', { price: 200 }));
-    expect(store.getOrders()).toHaveLength(1);
-    expect(store.getOrders()[0]!.price).toBe(200);
-  });
-
-  it('removeOrder removes by id', () => {
-    store.upsertOrder(makeOrder('o1'));
-    store.upsertOrder(makeOrder('o2'));
-    store.removeOrder('o1');
-    expect(store.getOrders()).toHaveLength(1);
-    expect(store.getOrders()[0]!.id).toBe('o2');
-  });
-
-  it('removeOrder is a silent no-op for unknown id', () => {
-    store.upsertOrder(makeOrder('o1'));
-    store.removeOrder('nonexistent');
-    expect(store.getOrders()).toHaveLength(1);
-  });
-
-  it('getOrdersByGroup filters correctly', () => {
-    store.setOrders([
-      makeOrder('entry', { groupId: 'bracket1', role: 'entry' }),
-      makeOrder('sl',    { groupId: 'bracket1', role: 'stop_loss' }),
-      makeOrder('tp',    { groupId: 'bracket1', role: 'take_profit' }),
-      makeOrder('lone',  { role: 'limit' }),  // no groupId
-    ]);
-    const group = store.getOrdersByGroup('bracket1');
-    expect(group).toHaveLength(3);
-    const roles = group.map(o => o.role).sort();
-    expect(roles).toEqual(['entry', 'stop_loss', 'take_profit']);
-  });
-
-  it('getOrdersByGroup returns [] for unknown groupId', () => {
-    store.upsertOrder(makeOrder('o1', { groupId: 'g1' }));
-    expect(store.getOrdersByGroup('g2')).toHaveLength(0);
-  });
-});
-
-// ─── Positions ────────────────────────────────────────────────────────────────
-
-describe('TradingOverlayStore — positions', () => {
-  let store: TradingOverlayStore;
-  beforeEach(() => { store = new TradingOverlayStore(); });
-
-  it('starts empty', () => {
-    expect(store.getPositions()).toHaveLength(0);
-  });
-
-  it('setPositions replaces the entire set', () => {
-    store.setPositions([makePosition('p1'), makePosition('p2')]);
-    expect(store.getPositions()).toHaveLength(2);
-    store.setPositions([]);
-    expect(store.getPositions()).toHaveLength(0);
-  });
-
-  it('upsertPosition inserts when missing', () => {
-    store.upsertPosition(makePosition('p1'));
-    expect(store.getPositions()).toHaveLength(1);
-  });
-
-  it('upsertPosition updates when id matches', () => {
-    store.upsertPosition(makePosition('p1', { qty: 1 }));
-    store.upsertPosition(makePosition('p1', { qty: 5 }));
-    expect(store.getPositions()).toHaveLength(1);
-    expect(store.getPositions()[0]!.qty).toBe(5);
-  });
-
-  it('removePosition removes by id', () => {
-    store.upsertPosition(makePosition('p1'));
-    store.removePosition('p1');
-    expect(store.getPositions()).toHaveLength(0);
-  });
-
-  it('removePosition is a silent no-op for unknown id', () => {
-    expect(() => store.removePosition('ghost')).not.toThrow();
-  });
-});
-
-// ─── Fills ────────────────────────────────────────────────────────────────────
-
-describe('TradingOverlayStore — fills', () => {
-  let store: TradingOverlayStore;
-  beforeEach(() => { store = new TradingOverlayStore(); });
-
-  it('starts empty', () => {
-    expect(store.getFills()).toHaveLength(0);
-  });
-
-  it('pushExecution appends fills in order', () => {
-    store.pushExecution(makeFill('f1'));
-    store.pushExecution(makeFill('f2'));
-    expect(store.getFills()).toHaveLength(2);
-    expect(store.getFills()[0]!.id).toBe('f1');
-    expect(store.getFills()[1]!.id).toBe('f2');
-  });
-
-  it('getFillsByOrder filters by orderId', () => {
-    store.pushExecution(makeFill('f1', 'orderA'));
-    store.pushExecution(makeFill('f2', 'orderB'));
-    store.pushExecution(makeFill('f3', 'orderA'));
-    const fills = store.getFillsByOrder('orderA');
-    expect(fills).toHaveLength(2);
-    expect(fills.map(f => f.id)).toEqual(['f1', 'f3']);
-  });
-
-  it('getFillsByOrder returns [] for unknown orderId', () => {
-    store.pushExecution(makeFill('f1', 'o1'));
-    expect(store.getFillsByOrder('unknown')).toHaveLength(0);
-  });
-});
-
-// ─── clear & snapshot ─────────────────────────────────────────────────────────
-
-describe('TradingOverlayStore — clear and snapshot', () => {
-  let store: TradingOverlayStore;
-  beforeEach(() => { store = new TradingOverlayStore(); });
-
-  it('clear() removes all state', () => {
-    store.upsertOrder(makeOrder('o1'));
-    store.upsertPosition(makePosition('p1'));
-    store.pushExecution(makeFill('f1'));
-    store.clear();
-    expect(store.getOrders()).toHaveLength(0);
-    expect(store.getPositions()).toHaveLength(0);
-    expect(store.getFills()).toHaveLength(0);
-  });
-
-  it('snapshot() reflects the current state', () => {
-    store.upsertOrder(makeOrder('o1'));
-    store.upsertPosition(makePosition('p1'));
-    store.pushExecution(makeFill('f1'));
-    const snap = store.snapshot();
-    expect(snap.orders).toHaveLength(1);
-    expect(snap.positions).toHaveLength(1);
-    expect(snap.fills).toHaveLength(1);
-  });
-});
-
-// ─── onChange subscription ────────────────────────────────────────────────────
-
-describe('TradingOverlayStore — onChange notifications', () => {
-  let store: TradingOverlayStore;
-  beforeEach(() => { store = new TradingOverlayStore(); });
-
-  function countCalls(fn: () => void): number {
-    const spy = vi.fn();
-    const unsub = store.onChange(spy);
-    fn();
-    unsub();
-    return spy.mock.calls.length;
-  }
-
-  it('fires on setOrders', () => {
-    expect(countCalls(() => store.setOrders([makeOrder('o1')]))).toBe(1);
-  });
-
-  it('fires on upsertOrder', () => {
-    expect(countCalls(() => store.upsertOrder(makeOrder('o1')))).toBe(1);
-  });
-
-  it('fires on removeOrder (when item exists)', () => {
-    store.upsertOrder(makeOrder('o1'));
-    expect(countCalls(() => store.removeOrder('o1'))).toBe(1);
-  });
-
-  it('does NOT fire on removeOrder for unknown id', () => {
-    expect(countCalls(() => store.removeOrder('ghost'))).toBe(0);
-  });
-
-  it('fires on setPositions', () => {
-    expect(countCalls(() => store.setPositions([makePosition('p1')]))).toBe(1);
-  });
-
-  it('fires on upsertPosition', () => {
-    expect(countCalls(() => store.upsertPosition(makePosition('p1')))).toBe(1);
-  });
-
-  it('fires on pushExecution', () => {
-    expect(countCalls(() => store.pushExecution(makeFill('f1')))).toBe(1);
-  });
-
-  it('fires on clear', () => {
-    expect(countCalls(() => store.clear())).toBe(1);
-  });
-
-  it('unsubscribe stops future notifications', () => {
-    const spy = vi.fn();
-    const unsub = store.onChange(spy);
-    unsub();
-    store.upsertOrder(makeOrder('o1'));
-    expect(spy).not.toHaveBeenCalled();
-  });
-});
-
-// ─── Shared overlay: both modes write into the same store ─────────────────────
-
-describe('TradingOverlayStore — shared between unmanaged and managed pathways', () => {
-  it('unmanaged push and managed push coexist in the same store', () => {
-    const store = new TradingOverlayStore();
-
-    // Simulate unmanaged host pushing an external position
-    store.upsertPosition(makePosition('ext-pos', { qty: 2 }));
-
-    // Simulate managed controller pushing an order (e.g. bracket entry)
-    store.upsertOrder(makeOrder('mgd-entry', { groupId: 'brk1', role: 'entry' }));
-    store.upsertOrder(makeOrder('mgd-sl',    { groupId: 'brk1', role: 'stop_loss',   price: 90 }));
-    store.upsertOrder(makeOrder('mgd-tp',    { groupId: 'brk1', role: 'take_profit', price: 115 }));
-
-    expect(store.getPositions()).toHaveLength(1);
-    expect(store.getOrders()).toHaveLength(3);
-    expect(store.getOrdersByGroup('brk1')).toHaveLength(3);
-  });
-
-  it('groupId-based bracket legs can coexist alongside unlinked orders', () => {
-    const store = new TradingOverlayStore();
-
-    store.upsertOrder(makeOrder('solo',   { role: 'limit' }));
-    store.upsertOrder(makeOrder('b1-ent', { groupId: 'brk-A', role: 'entry'       }));
-    store.upsertOrder(makeOrder('b1-sl',  { groupId: 'brk-A', role: 'stop_loss'   }));
-    store.upsertOrder(makeOrder('b1-tp',  { groupId: 'brk-A', role: 'take_profit' }));
-    store.upsertOrder(makeOrder('b2-ent', { groupId: 'brk-B', role: 'entry'       }));
-    store.upsertOrder(makeOrder('b2-sl',  { groupId: 'brk-B', role: 'stop_loss'   }));
-
-    expect(store.getOrders()).toHaveLength(6);
-    expect(store.getOrdersByGroup('brk-A')).toHaveLength(3);
-    expect(store.getOrdersByGroup('brk-B')).toHaveLength(2);
-  });
-
-  it('TP / SL / entry roles are stored verbatim', () => {
-    const store = new TradingOverlayStore();
-    const entry = makeOrder('entry-1', { role: 'entry',       price: 100 });
-    const sl    = makeOrder('sl-1',    { role: 'stop_loss',   price: 90  });
-    const tp    = makeOrder('tp-1',    { role: 'take_profit', price: 115 });
-    store.setOrders([entry, sl, tp]);
-
-    const orders = store.getOrders();
-    expect(orders.find(o => o.id === 'entry-1')!.role).toBe('entry');
-    expect(orders.find(o => o.id === 'sl-1')!.role).toBe('stop_loss');
-    expect(orders.find(o => o.id === 'tp-1')!.role).toBe('take_profit');
-  });
-});

package/src/trading/__tests__/UnmanagedIngestion.test.ts

@@ -1,205 +0,0 @@
-/**
- * UnmanagedIngestion — unit tests
- *
- * Covers:
- *   - setHistory loads bars in ascending order
- *   - pushCandle appends a new bar
- *   - pushCandle updates the current bar when same bucket
- *   - getLatestBar returns correct data
- *   - getBars() returns the full bar array
- *   - setTimeframe clears bars and resets engine
- *   - reset() wipes all bars
- *   - Throws when called in managed mode
- *   - onBarUpdated / onResync callbacks fire correctly
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { LicenseManager } from '../../licensing/LicenseManager';
-import { UnmanagedIngestion } from '../UnmanagedIngestion';
-import type { CandleInput } from '../tradingTypes';
-import type { CandleBar, UpdateResult } from '../../engine/CandleEngine';
-
-// ─── License helpers ──────────────────────────────────────────────────────────
-
-function installUnmanaged() {
-  LicenseManager.getInstance().loadLicense({ licenseKey: 'u', mode: 'unmanaged' });
-}
-
-function installManaged() {
-  LicenseManager.getInstance().loadLicense({ licenseKey: 'm', mode: 'managed' });
-}
-
-function clearLicense() {
-  LicenseManager.getInstance().clear();
-}
-
-// ─── Bar builders ─────────────────────────────────────────────────────────────
-
-// 2024-01-02 00:00:00 UTC in seconds
-const BASE_SEC = 1_704_153_600;
-const MIN      = 60; // seconds per minute
-
-function bar(offsetMinutes: number, close = 100, extra?: Partial<CandleInput>): CandleInput {
-  return {
-    time:  BASE_SEC + offsetMinutes * MIN,
-    open:  100,
-    high:  105,
-    low:   95,
-    close,
-    ...extra,
-  };
-}
-
-// ─── Mode gate ────────────────────────────────────────────────────────────────
-
-describe('UnmanagedIngestion — mode gate', () => {
-  afterEach(clearLicense);
-
-  it('setHistory() throws in managed mode', () => {
-    installManaged();
-    const ing = new UnmanagedIngestion('1m');
-    expect(() => ing.setHistory([bar(0)])).toThrow(/unmanaged/i);
-  });
-
-  it('pushCandle() throws in managed mode', () => {
-    installManaged();
-    const ing = new UnmanagedIngestion('1m');
-    expect(() => ing.pushCandle(bar(0))).toThrow(/unmanaged/i);
-  });
-
-  it('setHistory() works when no license is installed (defaults to unmanaged)', () => {
-    clearLicense();
-    const ing = new UnmanagedIngestion('1m');
-    expect(() => ing.setHistory([bar(0)])).not.toThrow();
-  });
-
-  it('pushCandle() works when no license is installed', () => {
-    clearLicense();
-    const ing = new UnmanagedIngestion('1m');
-    expect(() => ing.pushCandle(bar(0))).not.toThrow();
-  });
-});
-
-// ─── setHistory ───────────────────────────────────────────────────────────────
-
-describe('UnmanagedIngestion — setHistory', () => {
-  beforeEach(installUnmanaged);
-  afterEach(clearLicense);
-
-  it('loads bars and getBars() returns them', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1), bar(2)]);
-    expect(ing.getBars()).toHaveLength(3);
-  });
-
-  it('sorts bars ascending by time (even if fed out of order)', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(2), bar(0), bar(1)]);
-    const times = ing.getBars().map(b => b.time);
-    expect(times).toEqual([...times].sort((a, b) => a - b));
-  });
-
-  it('replaces previous history on second call', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1), bar(2)]);
-    ing.setHistory([bar(5), bar(6)]);
-    expect(ing.getBars()).toHaveLength(2);
-  });
-
-  it('getLatestBar() returns the newest bar after loading', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0, 100), bar(1, 200), bar(2, 300)]);
-    expect(ing.getLatestBar()!.close).toBe(300);
-  });
-
-  it('fires onResync with the loaded bars', () => {
-    const onResync = vi.fn<(bars: readonly CandleBar[]) => void>();
-    const ing = new UnmanagedIngestion('1m', { onResync });
-    ing.setHistory([bar(0), bar(1)]);
-    expect(onResync).toHaveBeenCalledTimes(1);
-    const passed = onResync.mock.calls[0]![0];
-    expect(passed).toHaveLength(2);
-  });
-});
-
-// ─── pushCandle ───────────────────────────────────────────────────────────────
-
-describe('UnmanagedIngestion — pushCandle', () => {
-  beforeEach(installUnmanaged);
-  afterEach(clearLicense);
-
-  it('appends a new bar when pushing beyond current candle', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1)]);
-    const result = ing.pushCandle(bar(2));
-    expect(result.type).toBe('append');
-    expect(ing.getBars()).toHaveLength(3);
-  });
-
-  it('updates the current bar when pushing same bucket', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0)]);
-    ing.pushCandle(bar(0, 110));  // same timestamp, new close
-    expect(ing.getBars()).toHaveLength(1);
-    expect(ing.getLatestBar()!.close).toBe(110);
-  });
-
-  it('high is never lowered within a candle', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.pushCandle(bar(0, 100, { high: 120 }));
-    ing.pushCandle(bar(0, 90,  { high: 80  }));  // high 80 < 120
-    expect(ing.getLatestBar()!.high).toBe(120);
-  });
-
-  it('low is never raised within a candle', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.pushCandle(bar(0, 100, { low: 80 }));
-    ing.pushCandle(bar(0, 95,  { low: 90 }));  // low 90 > 80
-    expect(ing.getLatestBar()!.low).toBe(80);
-  });
-
-  it('fires onBarUpdated for every push', () => {
-    const onBarUpdated = vi.fn<(bar: CandleBar, result: UpdateResult) => void>();
-    const ing = new UnmanagedIngestion('1m', { onBarUpdated });
-    ing.pushCandle(bar(0));
-    ing.pushCandle(bar(0, 110));
-    ing.pushCandle(bar(1));
-    expect(onBarUpdated).toHaveBeenCalledTimes(3);
-  });
-
-  it('getLatestBar() returns null before any data', () => {
-    const ing = new UnmanagedIngestion('1m');
-    expect(ing.getLatestBar()).toBeNull();
-  });
-});
-
-// ─── setTimeframe & reset ─────────────────────────────────────────────────────
-
-describe('UnmanagedIngestion — setTimeframe and reset', () => {
-  beforeEach(installUnmanaged);
-  afterEach(clearLicense);
-
-  it('setTimeframe clears all existing bars', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1), bar(2)]);
-    ing.setTimeframe('5m');
-    expect(ing.getBars()).toHaveLength(0);
-  });
-
-  it('reset() clears all bars', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1)]);
-    ing.reset();
-    expect(ing.getBars()).toHaveLength(0);
-    expect(ing.getLatestBar()).toBeNull();
-  });
-
-  it('new history can be loaded after setTimeframe', () => {
-    const ing = new UnmanagedIngestion('1m');
-    ing.setHistory([bar(0), bar(1)]);
-    ing.setTimeframe('5m');
-    // 5-minute bars (offset in multiples of 5)
-    ing.setHistory([bar(0), bar(5)]);
-    expect(ing.getBars()).toHaveLength(2);
-  });
-});