fix: rewrite tests for actual engine API, fix type exports

- Fix aggregator tests to match Aggregator class methods
- Fix alert tests for AlertManager API
- Fix collector tests for DataCollector signatures
- Rename Pipeline type to avoid conflicts in index.ts
- Fix tsconfig module resolution
- Add vitest to devDependencies

Author: idirdev

package.json

@@ -19,7 +19,7 @@
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "typescript": "^4.9.5",
+    "typescript": "^5.5.4",
     "@types/node": "^18.11.18",
     "@types/uuid": "^9.0.0",
     "ts-node": "^10.9.1",

src/index.ts

@@ -5,6 +5,8 @@ export { TimeSeriesStorage } from './Storage';
 export { AlertEngine } from './AlertEngine';
 export { DashboardQuery } from './Dashboard';
 export { bucketTimestamp, movingAverage, interpolateGaps, calculateRate } from './utils/timeseries';
+export { percentile, histogram, stddev, rate } from './utils/metrics';
+export { ReservoirSampler, RateLimiter, sampleArray } from './utils/sampling';
 
 export type {
   Event,
@@ -14,6 +16,7 @@ export type {
   TimeWindowSize,
   PipelineStage,
   PipelineStageType,
+  PipelineConfig,
   Filter,
   Aggregation,
   Dashboard,

src/types.ts

@@ -46,7 +46,7 @@ export interface PipelineStage {
   handler: (event: Event) => Event | null;
 }
 
-export interface Pipeline {
+export interface PipelineConfig {
   name: string;
   stages: PipelineStage[];
   errorHandler?: (error: Error, event: Event) => void;

src/utils/metrics.ts

@@ -28,17 +28,6 @@ export function histogram(values: number[], bucketCount: number): { min: number;
   return buckets;
 }
 
-export function movingAverage(values: number[], windowSize: number): number[] {
-  if (windowSize <= 0 || values.length === 0) return [];
-  const result: number[] = [];
-  for (let i = 0; i < values.length; i++) {
-    const start = Math.max(0, i - windowSize + 1);
-    const window = values.slice(start, i + 1);
-    result.push(window.reduce((a, b) => a + b, 0) / window.length);
-  }
-  return result;
-}
-
 export function stddev(values: number[]): number {
   if (values.length === 0) return 0;
   const mean = values.reduce((a, b) => a + b, 0) / values.length;

tests/aggregator.test.ts

@@ -2,40 +2,54 @@ import { describe, it, expect } from 'vitest';
 import { Aggregator } from '../src/Aggregator';
 
 describe('Aggregator', () => {
+  const now = Date.now();
+
   it('aggregates count', () => {
-    const agg = new Aggregator({ windowMs: 60000 });
-    agg.add({ metric: 'pageview', value: 1, timestamp: Date.now() });
-    agg.add({ metric: 'pageview', value: 1, timestamp: Date.now() });
-    expect(agg.getCount('pageview')).toBe(2);
+    const agg = new Aggregator('1m');
+    agg.add({ name: 'pageview', value: 1, timestamp: now, dimensions: {} });
+    agg.add({ name: 'pageview', value: 1, timestamp: now, dimensions: {} });
+    const results = agg.forceFlushAll();
+    const pv = results.find((r) => r.name === 'pageview');
+    expect(pv).toBeDefined();
+    expect(pv!.count).toBe(2);
   });
 
   it('aggregates sum', () => {
-    const agg = new Aggregator({ windowMs: 60000 });
-    agg.add({ metric: 'response_time', value: 120, timestamp: Date.now() });
-    agg.add({ metric: 'response_time', value: 80, timestamp: Date.now() });
-    expect(agg.getSum('response_time')).toBe(200);
+    const agg = new Aggregator('1m');
+    agg.add({ name: 'response_time', value: 120, timestamp: now, dimensions: {} });
+    agg.add({ name: 'response_time', value: 80, timestamp: now, dimensions: {} });
+    const results = agg.forceFlushAll();
+    const rt = results.find((r) => r.name === 'response_time');
+    expect(rt).toBeDefined();
+    expect(rt!.sum).toBe(200);
   });
 
   it('calculates average', () => {
-    const agg = new Aggregator({ windowMs: 60000 });
-    agg.add({ metric: 'latency', value: 100, timestamp: Date.now() });
-    agg.add({ metric: 'latency', value: 200, timestamp: Date.now() });
-    agg.add({ metric: 'latency', value: 300, timestamp: Date.now() });
-    expect(agg.getAverage('latency')).toBe(200);
+    const agg = new Aggregator('1m');
+    agg.add({ name: 'latency', value: 100, timestamp: now, dimensions: {} });
+    agg.add({ name: 'latency', value: 200, timestamp: now, dimensions: {} });
+    agg.add({ name: 'latency', value: 300, timestamp: now, dimensions: {} });
+    const results = agg.forceFlushAll();
+    const lat = results.find((r) => r.name === 'latency');
+    expect(lat).toBeDefined();
+    expect(lat!.avg).toBe(200);
   });
 
-  it('returns 0 for unknown metric', () => {
-    const agg = new Aggregator({ windowMs: 60000 });
-    expect(agg.getCount('unknown')).toBe(0);
-    expect(agg.getSum('unknown')).toBe(0);
+  it('returns empty for no metrics', () => {
+    const agg = new Aggregator('1m');
+    const results = agg.forceFlushAll();
+    expect(results).toHaveLength(0);
   });
 
   it('tracks min and max', () => {
-    const agg = new Aggregator({ windowMs: 60000 });
-    agg.add({ metric: 'cpu', value: 45, timestamp: Date.now() });
-    agg.add({ metric: 'cpu', value: 92, timestamp: Date.now() });
-    agg.add({ metric: 'cpu', value: 67, timestamp: Date.now() });
-    expect(agg.getMin('cpu')).toBe(45);
-    expect(agg.getMax('cpu')).toBe(92);
+    const agg = new Aggregator('1m');
+    agg.add({ name: 'cpu', value: 45, timestamp: now, dimensions: {} });
+    agg.add({ name: 'cpu', value: 92, timestamp: now, dimensions: {} });
+    agg.add({ name: 'cpu', value: 67, timestamp: now, dimensions: {} });
+    const results = agg.forceFlushAll();
+    const cpu = results.find((r) => r.name === 'cpu');
+    expect(cpu).toBeDefined();
+    expect(cpu!.min).toBe(45);
+    expect(cpu!.max).toBe(92);
   });
 });

tests/alert.test.ts

@@ -1,46 +1,107 @@
 import { describe, it, expect, vi } from 'vitest';
 import { AlertEngine } from '../src/AlertEngine';
+import { AlertRule, AggregatedMetric } from '../src/types';
+
+function makeMetric(name: string, avg: number): AggregatedMetric {
+  return {
+    name,
+    windowStart: Date.now() - 60000,
+    windowEnd: Date.now(),
+    count: 1,
+    sum: avg,
+    avg,
+    min: avg,
+    max: avg,
+    percentiles: { 50: avg, 90: avg, 95: avg, 99: avg },
+    dimensions: {},
+  };
+}
 
 describe('AlertEngine', () => {
   it('fires alert when threshold exceeded', () => {
-    const handler = vi.fn();
+    const listener = vi.fn();
     const engine = new AlertEngine();
-    engine.addRule({ metric: 'cpu', threshold: 90, operator: '>', handler });
-    engine.evaluate({ metric: 'cpu', value: 95, timestamp: Date.now() });
-    expect(handler).toHaveBeenCalled();
+    engine.onAlert(listener);
+    engine.addRule({
+      id: 'r1',
+      name: 'High CPU',
+      metric: 'cpu',
+      condition: { type: 'threshold', operator: 'gt', value: 90 },
+      actions: [{ type: 'log', config: {} }],
+      cooldownMs: 0,
+      enabled: true,
+    });
+    engine.evaluate(makeMetric('cpu', 95));
+    expect(listener).toHaveBeenCalled();
   });
 
   it('does not fire when below threshold', () => {
-    const handler = vi.fn();
+    const listener = vi.fn();
     const engine = new AlertEngine();
-    engine.addRule({ metric: 'cpu', threshold: 90, operator: '>', handler });
-    engine.evaluate({ metric: 'cpu', value: 70, timestamp: Date.now() });
-    expect(handler).not.toHaveBeenCalled();
+    engine.onAlert(listener);
+    engine.addRule({
+      id: 'r2',
+      name: 'High CPU',
+      metric: 'cpu',
+      condition: { type: 'threshold', operator: 'gt', value: 90 },
+      actions: [{ type: 'log', config: {} }],
+      cooldownMs: 0,
+      enabled: true,
+    });
+    engine.evaluate(makeMetric('cpu', 70));
+    expect(listener).not.toHaveBeenCalled();
   });
 
   it('supports less-than operator', () => {
-    const handler = vi.fn();
+    const listener = vi.fn();
     const engine = new AlertEngine();
-    engine.addRule({ metric: 'disk_free', threshold: 10, operator: '<', handler });
-    engine.evaluate({ metric: 'disk_free', value: 5, timestamp: Date.now() });
-    expect(handler).toHaveBeenCalled();
+    engine.onAlert(listener);
+    engine.addRule({
+      id: 'r3',
+      name: 'Low Disk',
+      metric: 'disk_free',
+      condition: { type: 'threshold', operator: 'lt', value: 10 },
+      actions: [{ type: 'log', config: {} }],
+      cooldownMs: 0,
+      enabled: true,
+    });
+    engine.evaluate(makeMetric('disk_free', 5));
+    expect(listener).toHaveBeenCalled();
   });
 
   it('respects cooldown period', () => {
-    const handler = vi.fn();
+    const listener = vi.fn();
     const engine = new AlertEngine();
-    engine.addRule({ metric: 'errors', threshold: 100, operator: '>', handler, cooldownMs: 60000 });
-    engine.evaluate({ metric: 'errors', value: 150, timestamp: Date.now() });
-    engine.evaluate({ metric: 'errors', value: 160, timestamp: Date.now() });
-    expect(handler).toHaveBeenCalledTimes(1);
+    engine.onAlert(listener);
+    engine.addRule({
+      id: 'r4',
+      name: 'High Errors',
+      metric: 'errors',
+      condition: { type: 'threshold', operator: 'gt', value: 100 },
+      actions: [{ type: 'log', config: {} }],
+      cooldownMs: 60000,
+      enabled: true,
+    });
+    engine.evaluate(makeMetric('errors', 150));
+    engine.evaluate(makeMetric('errors', 160));
+    expect(listener).toHaveBeenCalledTimes(1);
   });
 
   it('removes rules', () => {
-    const handler = vi.fn();
+    const listener = vi.fn();
     const engine = new AlertEngine();
-    const id = engine.addRule({ metric: 'mem', threshold: 80, operator: '>', handler });
-    engine.removeRule(id);
-    engine.evaluate({ metric: 'mem', value: 95, timestamp: Date.now() });
-    expect(handler).not.toHaveBeenCalled();
+    engine.onAlert(listener);
+    engine.addRule({
+      id: 'r5',
+      name: 'High Mem',
+      metric: 'mem',
+      condition: { type: 'threshold', operator: 'gt', value: 80 },
+      actions: [{ type: 'log', config: {} }],
+      cooldownMs: 0,
+      enabled: true,
+    });
+    engine.removeRule('r5');
+    engine.evaluate(makeMetric('mem', 95));
+    expect(listener).not.toHaveBeenCalled();
   });
 });

tests/collector.test.ts

@@ -3,44 +3,53 @@ import { EventCollector } from '../src/EventCollector';
 
 describe('EventCollector', () => {
   it('collects events', () => {
-    const collector = new EventCollector({ batchSize: 10 });
-    collector.push({ type: 'click', data: { x: 100, y: 200 } });
-    expect(collector.size).toBe(1);
+    const collector = new EventCollector();
+    collector.ingest({ name: 'click', properties: { x: 100, y: 200 } });
+    expect(collector.getBufferSize()).toBe(1);
   });
 
   it('deduplicates by event id', () => {
-    const collector = new EventCollector({ batchSize: 10, deduplicate: true });
-    collector.push({ id: 'evt-1', type: 'click', data: {} });
-    collector.push({ id: 'evt-1', type: 'click', data: {} });
-    expect(collector.size).toBe(1);
+    const collector = new EventCollector();
+    collector.ingest({ id: 'evt-1', name: 'click', properties: {} });
+    collector.ingest({ id: 'evt-1', name: 'click', properties: {} });
+    expect(collector.getBufferSize()).toBe(1);
   });
 
-  it('flushes when batch size reached', () => {
-    const onFlush = vi.fn();
-    const collector = new EventCollector({ batchSize: 3, onFlush });
-    collector.push({ type: 'a', data: {} });
-    collector.push({ type: 'b', data: {} });
-    collector.push({ type: 'c', data: {} });
-    expect(onFlush).toHaveBeenCalledTimes(1);
-    expect(onFlush).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({ type: 'a' }),
-    ]));
+  it('rejects events without a name', () => {
+    const collector = new EventCollector();
+    const result = collector.ingest({ properties: {} });
+    expect(result).toBeNull();
+    expect(collector.getBufferSize()).toBe(0);
   });
 
   it('manual flush empties buffer', () => {
-    const collector = new EventCollector({ batchSize: 100 });
-    collector.push({ type: 'test', data: {} });
+    const collector = new EventCollector();
+    collector.ingest({ name: 'test', properties: {} });
     const flushed = collector.flush();
     expect(flushed).toHaveLength(1);
-    expect(collector.size).toBe(0);
+    expect(collector.getBufferSize()).toBe(0);
+  });
+
+  it('assigns default source tag', () => {
+    const collector = new EventCollector({ sourceTag: 'web' });
+    const event = collector.ingest({ name: 'pageview', properties: {} });
+    expect(event).toBeDefined();
+    expect(event!.source).toBe('web');
   });
 
-  it('drops events when buffer full', () => {
-    const collector = new EventCollector({ batchSize: 100, maxBuffer: 2 });
-    collector.push({ type: 'a', data: {} });
-    collector.push({ type: 'b', data: {} });
-    collector.push({ type: 'c', data: {} });
-    expect(collector.size).toBe(2);
-    expect(collector.dropped).toBe(1);
+  it('normalizes event name to lowercase', () => {
+    const collector = new EventCollector();
+    const event = collector.ingest({ name: 'PageView', properties: {} });
+    expect(event).toBeDefined();
+    expect(event!.name).toBe('pageview');
+  });
+
+  it('destroy flushes and clears', () => {
+    const onFlush = vi.fn();
+    const collector = new EventCollector({ onFlush, flushIntervalMs: 100000 });
+    collector.ingest({ name: 'test', properties: {} });
+    collector.destroy();
+    expect(onFlush).toHaveBeenCalled();
+    expect(collector.getBufferSize()).toBe(0);
   });
 });

tsconfig.json

@@ -4,7 +4,7 @@
     "module": "commonjs",
     "lib": ["ES2021"],
     "outDir": "dist",
-    "rootDir": ".",
+    "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
@@ -14,6 +14,6 @@
     "declarationMap": true,
     "sourceMap": true
   },
-  "include": ["src/**/*", "examples/**/*"],
+  "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
 }