@holoscript/framework 6.0.3

package/src/swarm/analytics/__tests__/SwarmInspector.test.ts

@@ -0,0 +1,454 @@
+/**
+ * SwarmInspector Tests
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { SwarmInspector, IAgentSnapshot, ISwarmSnapshot } from '../SwarmInspector';
+
+describe('SwarmInspector', () => {
+  let inspector: SwarmInspector;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T00:00:00Z'));
+    inspector = new SwarmInspector();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('agent tracking', () => {
+    const createAgent = (id: string, overrides?: Partial<IAgentSnapshot>): IAgentSnapshot => ({
+      id,
+      state: 'active',
+      health: 1.0,
+      load: 0.5,
+      lastActive: Date.now(),
+      properties: {},
+      ...overrides,
+    });
+
+    it('should update agent snapshot', () => {
+      const agent = createAgent('agent-1');
+      inspector.updateAgent(agent);
+
+      expect(inspector.getAgent('agent-1')).toEqual(agent);
+    });
+
+    it('should remove agent snapshot', () => {
+      inspector.updateAgent(createAgent('agent-1'));
+      inspector.removeAgent('agent-1');
+
+      expect(inspector.getAgent('agent-1')).toBeUndefined();
+    });
+
+    it('should get all agents', () => {
+      inspector.updateAgent(createAgent('a1'));
+      inspector.updateAgent(createAgent('a2'));
+      inspector.updateAgent(createAgent('a3'));
+
+      expect(inspector.getAllAgents()).toHaveLength(3);
+    });
+
+    it('should get agents by swarm', () => {
+      inspector.updateAgent(createAgent('a1', { swarmId: 'swarm-1' }));
+      inspector.updateAgent(createAgent('a2', { swarmId: 'swarm-1' }));
+      inspector.updateAgent(createAgent('a3', { swarmId: 'swarm-2' }));
+
+      expect(inspector.getSwarmAgents('swarm-1')).toHaveLength(2);
+      expect(inspector.getSwarmAgents('swarm-2')).toHaveLength(1);
+    });
+
+    it('should remove relations when agent removed', () => {
+      inspector.updateAgent(createAgent('a1'));
+      inspector.updateAgent(createAgent('a2'));
+      inspector.addRelation({
+        sourceId: 'a1',
+        targetId: 'a2',
+        type: 'neighbor',
+        strength: 0.8,
+      });
+
+      inspector.removeAgent('a1');
+
+      expect(inspector.getAgentRelations('a2')).toHaveLength(0);
+    });
+  });
+
+  describe('swarm tracking', () => {
+    const createSwarm = (id: string, overrides?: Partial<ISwarmSnapshot>): ISwarmSnapshot => ({
+      id,
+      memberCount: 5,
+      state: 'active',
+      createdAt: Date.now(),
+      properties: {},
+      ...overrides,
+    });
+
+    it('should update swarm snapshot', () => {
+      const swarm = createSwarm('swarm-1');
+      inspector.updateSwarm(swarm);
+
+      expect(inspector.getSwarm('swarm-1')).toEqual(swarm);
+    });
+
+    it('should remove swarm snapshot', () => {
+      inspector.updateSwarm(createSwarm('swarm-1'));
+      inspector.removeSwarm('swarm-1');
+
+      expect(inspector.getSwarm('swarm-1')).toBeUndefined();
+    });
+
+    it('should get all swarms', () => {
+      inspector.updateSwarm(createSwarm('s1'));
+      inspector.updateSwarm(createSwarm('s2'));
+
+      expect(inspector.getAllSwarms()).toHaveLength(2);
+    });
+  });
+
+  describe('relations', () => {
+    it('should add relation between agents', () => {
+      inspector.addRelation({
+        sourceId: 'a1',
+        targetId: 'a2',
+        type: 'neighbor',
+        strength: 0.7,
+      });
+
+      const relations = inspector.getAllRelations();
+      expect(relations).toHaveLength(1);
+      expect(relations[0].strength).toBe(0.7);
+    });
+
+    it('should update existing relation', () => {
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.5 });
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.9 });
+
+      const relations = inspector.getAllRelations();
+      expect(relations).toHaveLength(1);
+      expect(relations[0].strength).toBe(0.9);
+    });
+
+    it('should allow different relation types', () => {
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.5 });
+      inspector.addRelation({
+        sourceId: 'a1',
+        targetId: 'a2',
+        type: 'communication',
+        strength: 0.8,
+      });
+
+      expect(inspector.getAllRelations()).toHaveLength(2);
+    });
+
+    it('should remove relation', () => {
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.5 });
+      inspector.removeRelation('a1', 'a2', 'neighbor');
+
+      expect(inspector.getAllRelations()).toHaveLength(0);
+    });
+
+    it('should get relations for agent', () => {
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.5 });
+      inspector.addRelation({ sourceId: 'a3', targetId: 'a1', type: 'neighbor', strength: 0.6 });
+      inspector.addRelation({ sourceId: 'a2', targetId: 'a3', type: 'neighbor', strength: 0.7 });
+
+      const a1Relations = inspector.getAgentRelations('a1');
+      expect(a1Relations).toHaveLength(2);
+    });
+  });
+
+  describe('health checks', () => {
+    it('should register health check', () => {
+      inspector.registerHealthCheck({
+        name: 'database',
+        status: 'healthy',
+        latency: 5,
+        lastCheck: Date.now(),
+      });
+
+      expect(inspector.getHealthCheck('database')?.status).toBe('healthy');
+    });
+
+    it('should get all health checks', () => {
+      inspector.registerHealthCheck({ name: 'db', status: 'healthy', lastCheck: Date.now() });
+      inspector.registerHealthCheck({ name: 'cache', status: 'degraded', lastCheck: Date.now() });
+
+      expect(inspector.getAllHealthChecks()).toHaveLength(2);
+    });
+
+    it('should return healthy when all checks pass', () => {
+      inspector.registerHealthCheck({ name: 'db', status: 'healthy', lastCheck: Date.now() });
+      inspector.registerHealthCheck({ name: 'cache', status: 'healthy', lastCheck: Date.now() });
+
+      expect(inspector.getOverallHealth()).toBe('healthy');
+    });
+
+    it('should return degraded when any check degraded', () => {
+      inspector.registerHealthCheck({ name: 'db', status: 'healthy', lastCheck: Date.now() });
+      inspector.registerHealthCheck({ name: 'cache', status: 'degraded', lastCheck: Date.now() });
+
+      expect(inspector.getOverallHealth()).toBe('degraded');
+    });
+
+    it('should return unhealthy when any check unhealthy', () => {
+      inspector.registerHealthCheck({ name: 'db', status: 'unhealthy', lastCheck: Date.now() });
+      inspector.registerHealthCheck({ name: 'cache', status: 'healthy', lastCheck: Date.now() });
+
+      expect(inspector.getOverallHealth()).toBe('unhealthy');
+    });
+  });
+
+  describe('debug events', () => {
+    it('should log events with different levels', () => {
+      inspector.trace('source1', 'trace message');
+      inspector.debug('source1', 'debug message');
+      inspector.info('source1', 'info message');
+      inspector.warn('source1', 'warn message');
+      inspector.error('source1', 'error message');
+
+      const log = inspector.getEventLog();
+      expect(log).toHaveLength(5);
+      expect(log.map((e) => e.level)).toEqual(['trace', 'debug', 'info', 'warn', 'error']);
+    });
+
+    it('should filter events by level', () => {
+      inspector.info('src', 'info');
+      inspector.error('src', 'error');
+
+      expect(inspector.getEventLog({ level: 'error' })).toHaveLength(1);
+    });
+
+    it('should filter events by source', () => {
+      inspector.info('source-a', 'msg1');
+      inspector.info('source-b', 'msg2');
+
+      expect(inspector.getEventLog({ source: 'source-a' })).toHaveLength(1);
+    });
+
+    it('should filter events by timestamp', () => {
+      inspector.info('src', 'old');
+      vi.advanceTimersByTime(5000);
+      const cutoff = Date.now();
+      vi.advanceTimersByTime(5000);
+      inspector.info('src', 'new');
+
+      expect(inspector.getEventLog({ since: cutoff })).toHaveLength(1);
+    });
+
+    it('should limit events returned', () => {
+      for (let i = 0; i < 10; i++) {
+        inspector.info('src', `msg ${i}`);
+      }
+
+      expect(inspector.getEventLog({ limit: 3 })).toHaveLength(3);
+    });
+
+    it('should support event listeners', () => {
+      const events: string[] = [];
+      const unsubscribe = inspector.addEventListener((e) => events.push(e.message));
+
+      inspector.info('src', 'message1');
+      inspector.info('src', 'message2');
+
+      expect(events).toEqual(['message1', 'message2']);
+
+      unsubscribe();
+      inspector.info('src', 'message3');
+
+      expect(events).toHaveLength(2);
+    });
+
+    it('should respect maxEvents limit', () => {
+      const limitedInspector = new SwarmInspector({ maxEvents: 5 });
+
+      for (let i = 0; i < 10; i++) {
+        limitedInspector.info('src', `msg ${i}`);
+      }
+
+      const log = limitedInspector.getEventLog();
+      expect(log).toHaveLength(5);
+      expect(log[0].message).toBe('msg 5');
+    });
+
+    it('should clear event log', () => {
+      inspector.info('src', 'message');
+      inspector.clearEventLog();
+
+      expect(inspector.getEventLog()).toHaveLength(0);
+    });
+  });
+
+  describe('inspect', () => {
+    it('should return full inspection result', () => {
+      inspector.updateSwarm({
+        id: 'swarm-1',
+        memberCount: 3,
+        state: 'active',
+        createdAt: Date.now(),
+        properties: {},
+      });
+
+      inspector.updateAgent({
+        id: 'a1',
+        swarmId: 'swarm-1',
+        state: 'active',
+        health: 1.0,
+        load: 0.3,
+        lastActive: Date.now(),
+        properties: {},
+      });
+
+      inspector.registerHealthCheck({
+        name: 'test',
+        status: 'healthy',
+        lastCheck: Date.now(),
+      });
+
+      const result = inspector.inspect();
+      expect(result.swarms).toHaveLength(1);
+      expect(result.agents).toHaveLength(1);
+      expect(result.health).toHaveLength(1);
+      expect(result.summary.totalSwarms).toBe(1);
+      expect(result.summary.totalAgents).toBe(1);
+    });
+
+    it('should detect low health agents', () => {
+      inspector.updateAgent({
+        id: 'a1',
+        state: 'active',
+        health: 0.2,
+        load: 0.5,
+        lastActive: Date.now(),
+        properties: {},
+      });
+
+      const result = inspector.inspect();
+      expect(result.summary.healthyAgents).toBe(0);
+      expect(result.summary.warnings).toContain('1 agents have low health');
+    });
+
+    it('should detect overloaded agents', () => {
+      inspector.updateAgent({
+        id: 'a1',
+        state: 'active',
+        health: 1.0,
+        load: 0.95,
+        lastActive: Date.now(),
+        properties: {},
+      });
+
+      const result = inspector.inspect();
+      expect(result.summary.warnings).toContain('1 agents are overloaded');
+    });
+
+    it('should detect stale agents', () => {
+      inspector.updateAgent({
+        id: 'a1',
+        state: 'active',
+        health: 1.0,
+        load: 0.5,
+        lastActive: Date.now() - 120000, // 2 min ago
+        properties: {},
+      });
+
+      const result = inspector.inspect();
+      expect(result.summary.warnings).toContain('1 agents are stale');
+    });
+
+    it('should calculate average load', () => {
+      inspector.updateAgent({
+        id: 'a1',
+        state: 'active',
+        health: 1.0,
+        load: 0.4,
+        lastActive: Date.now(),
+        properties: {},
+      });
+      inspector.updateAgent({
+        id: 'a2',
+        state: 'active',
+        health: 1.0,
+        load: 0.6,
+        lastActive: Date.now(),
+        properties: {},
+      });
+
+      const result = inspector.inspect();
+      expect(result.summary.averageLoad).toBe(0.5);
+    });
+  });
+
+  describe('toGraph', () => {
+    it('should generate graph with nodes and edges', () => {
+      inspector.updateSwarm({
+        id: 'swarm-1',
+        memberCount: 2,
+        state: 'active',
+        createdAt: Date.now(),
+        properties: {},
+      });
+
+      inspector.updateAgent({
+        id: 'a1',
+        swarmId: 'swarm-1',
+        state: 'active',
+        health: 1.0,
+        load: 0.5,
+        lastActive: Date.now(),
+        properties: {},
+      });
+
+      inspector.addRelation({
+        sourceId: 'a1',
+        targetId: 'a2',
+        type: 'neighbor',
+        strength: 0.7,
+      });
+
+      const graph = inspector.toGraph();
+
+      expect(graph.nodes.find((n) => n.id === 'swarm-1')).toBeDefined();
+      expect(graph.nodes.find((n) => n.id === 'a1')).toBeDefined();
+
+      // Edge for swarm membership
+      expect(graph.edges.find((e) => e.source === 'a1' && e.target === 'swarm-1')).toBeDefined();
+      // Edge for relation
+      expect(graph.edges.find((e) => e.source === 'a1' && e.target === 'a2')).toBeDefined();
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear all state', () => {
+      inspector.updateSwarm({
+        id: 's1',
+        memberCount: 1,
+        state: 'active',
+        createdAt: Date.now(),
+        properties: {},
+      });
+      inspector.updateAgent({
+        id: 'a1',
+        state: 'active',
+        health: 1.0,
+        load: 0.5,
+        lastActive: Date.now(),
+        properties: {},
+      });
+      inspector.addRelation({ sourceId: 'a1', targetId: 'a2', type: 'neighbor', strength: 0.5 });
+      inspector.registerHealthCheck({ name: 'test', status: 'healthy', lastCheck: Date.now() });
+      inspector.info('src', 'message');
+
+      inspector.reset();
+
+      expect(inspector.getAllSwarms()).toHaveLength(0);
+      expect(inspector.getAllAgents()).toHaveLength(0);
+      expect(inspector.getAllRelations()).toHaveLength(0);
+      expect(inspector.getAllHealthChecks()).toHaveLength(0);
+      expect(inspector.getEventLog()).toHaveLength(0);
+    });
+  });
+});

package/src/swarm/analytics/__tests__/SwarmMetrics.prod.test.ts

@@ -0,0 +1,254 @@
+/**
+ * SwarmMetrics — Production Tests
+ */
+import { describe, it, expect } from 'vitest';
+import { SwarmMetrics } from '../SwarmMetrics';
+
+function make(cfg = {}) {
+  return new SwarmMetrics(cfg);
+}
+
+describe('SwarmMetrics — construction', () => {
+  it('constructs without args', () => expect(() => make()).not.toThrow());
+  it('custom retentionPeriod', () => expect(() => make({ retentionPeriod: 60000 })).not.toThrow());
+});
+
+describe('SwarmMetrics — counter', () => {
+  it('registers counter at 0', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    expect(m.getCounter('c')).toBe(0);
+  });
+  it('increment by 1', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c');
+    expect(m.getCounter('c')).toBe(1);
+  });
+  it('increment by value', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c', 5);
+    expect(m.getCounter('c')).toBe(5);
+  });
+  it('accumulates multiple increments', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c', 3);
+    m.increment('c', 4);
+    expect(m.getCounter('c')).toBe(7);
+  });
+  it('unregistered counter returns 0', () => {
+    expect(make().getCounter('ghost')).toBe(0);
+  });
+  it('reset counter to 0', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c', 10);
+    m.reset('c');
+    expect(m.getCounter('c')).toBe(0);
+  });
+  it('getStats counter: min=max=avg=value', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c', 7);
+    const s = m.getStats('c')!;
+    expect(s.currentValue).toBe(7);
+    expect(s.min).toBe(7);
+    expect(s.max).toBe(7);
+  });
+});
+
+describe('SwarmMetrics — gauge', () => {
+  it('setGauge stores value', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.setGauge('g', 42);
+    expect(m.getGauge('g')).toBe(42);
+  });
+  it('getGauge returns latest value', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.setGauge('g', 10);
+    m.setGauge('g', 20);
+    expect(m.getGauge('g')).toBe(20);
+  });
+  it('getGauge undefined for no values', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    expect(m.getGauge('g')).toBeUndefined();
+  });
+  it('getGaugeHistory returns all values', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.setGauge('g', 1);
+    m.setGauge('g', 2);
+    m.setGauge('g', 3);
+    expect(m.getGaugeHistory('g')).toHaveLength(3);
+  });
+  it('getStats gauge: min/max/avg correct', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.setGauge('g', 10);
+    m.setGauge('g', 20);
+    m.setGauge('g', 30);
+    const s = m.getStats('g')!;
+    expect(s.min).toBe(10);
+    expect(s.max).toBe(30);
+    expect(s.avg).toBe(20);
+  });
+  it('reset gauge clears values', () => {
+    const m = make();
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.setGauge('g', 99);
+    m.reset('g');
+    expect(m.getGauge('g')).toBeUndefined();
+  });
+});
+
+describe('SwarmMetrics — histogram', () => {
+  it('observeHistogram adds to count', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.observeHistogram('h', 5);
+    m.observeHistogram('h', 10);
+    expect(m.getHistogram('h')!.count).toBe(2);
+  });
+  it('sum accumulates correctly', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.observeHistogram('h', 3);
+    m.observeHistogram('h', 7);
+    expect(m.getHistogram('h')!.sum).toBe(10);
+  });
+  it('setHistogramBoundaries updates buckets', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.setHistogramBoundaries('h', [1, 5, 10]);
+    expect(m.getHistogram('h')!.boundaries).toHaveLength(3);
+  });
+  it('values bucketed correctly', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.setHistogramBoundaries('h', [1, 5, 10]);
+    m.observeHistogram('h', 3); // in bucket [1,5]
+    const hist = m.getHistogram('h')!;
+    expect(hist.counts[1]).toBe(1); // boundary index 1 = le=5
+  });
+  it('getStats histogram: avg = sum/count', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.observeHistogram('h', 4);
+    m.observeHistogram('h', 6);
+    expect(m.getStats('h')!.avg).toBe(5);
+  });
+  it('reset histogram clears', () => {
+    const m = make();
+    m.register({ name: 'h', type: 'histogram', description: 'test' });
+    m.observeHistogram('h', 5);
+    m.reset('h');
+    expect(m.getHistogram('h')!.count).toBe(0);
+  });
+});
+
+describe('SwarmMetrics — summary', () => {
+  it('observeSummary stores values', () => {
+    const m = make();
+    m.register({ name: 's', type: 'summary', description: 'test' });
+    m.observeSummary('s', 10);
+    m.observeSummary('s', 20);
+    expect(m.getSummary('s')!.count).toBe(2);
+  });
+  it('getSummary percentiles correct', () => {
+    const m = make();
+    m.register({ name: 's', type: 'summary', description: 'test' });
+    for (let i = 1; i <= 100; i++) m.observeSummary('s', i);
+    const p = m.getSummary('s')!;
+    expect(p.p50).toBeGreaterThanOrEqual(50);
+    expect(p.p99).toBeGreaterThanOrEqual(99);
+  });
+  it('getSummary undefined for no observations', () => {
+    const m = make();
+    m.register({ name: 's', type: 'summary', description: 'test' });
+    expect(m.getSummary('s')).toBeUndefined();
+  });
+  it('getStats summary: min/max/avg', () => {
+    const m = make();
+    m.register({ name: 's', type: 'summary', description: 'test' });
+    m.observeSummary('s', 2);
+    m.observeSummary('s', 4);
+    m.observeSummary('s', 6);
+    const s = m.getStats('s')!;
+    expect(s.min).toBe(2);
+    expect(s.max).toBe(6);
+    expect(s.avg).toBe(4);
+  });
+  it('maxSamples trims oldest', () => {
+    const m = make({ maxSamples: 3 });
+    m.register({ name: 's', type: 'summary', description: 'test' });
+    for (let i = 0; i < 5; i++) m.observeSummary('s', i);
+    expect(m.getSummary('s')!.count).toBe(3);
+  });
+});
+
+describe('SwarmMetrics — getRegistered / getAllStats / resetAll', () => {
+  it('getRegistered returns all defs', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'a' });
+    m.register({ name: 'g', type: 'gauge', description: 'b' });
+    expect(m.getRegistered()).toHaveLength(2);
+  });
+  it('getAllStats returns stats for all', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.register({ name: 'g', type: 'gauge', description: 'test' });
+    m.increment('c', 5);
+    m.setGauge('g', 3);
+    const all = m.getAllStats();
+    expect(all['c'].currentValue).toBe(5);
+  });
+  it('resetAll resets every metric', () => {
+    const m = make();
+    m.register({ name: 'c', type: 'counter', description: 'test' });
+    m.increment('c', 100);
+    m.resetAll();
+    expect(m.getCounter('c')).toBe(0);
+  });
+  it('getStats undefined for unregistered', () => {
+    expect(make().getStats('ghost')).toBeUndefined();
+  });
+});
+
+describe('SwarmMetrics — toPrometheus', () => {
+  it('counter exported', () => {
+    const m = make();
+    m.register({ name: 'req_total', type: 'counter', description: 'Requests' });
+    m.increment('req_total', 7);
+    const prom = m.toPrometheus();
+    expect(prom).toContain('req_total 7');
+    expect(prom).toContain('# HELP req_total Requests');
+  });
+  it('gauge exported', () => {
+    const m = make();
+    m.register({ name: 'mem_bytes', type: 'gauge', description: 'Memory' });
+    m.setGauge('mem_bytes', 512);
+    expect(m.toPrometheus()).toContain('mem_bytes 512');
+  });
+  it('histogram buckets exported', () => {
+    const m = make();
+    m.register({ name: 'latency', type: 'histogram', description: 'Latency' });
+    m.observeHistogram('latency', 0.3);
+    const prom = m.toPrometheus();
+    expect(prom).toContain('latency_bucket');
+    expect(prom).toContain('latency_sum');
+    expect(prom).toContain('latency_count');
+  });
+  it('summary quantiles exported', () => {
+    const m = make();
+    m.register({ name: 'resp', type: 'summary', description: 'Response' });
+    for (let i = 1; i <= 20; i++) m.observeSummary('resp', i);
+    const prom = m.toPrometheus();
+    expect(prom).toContain('quantile="0.5"');
+    expect(prom).toContain('quantile="0.99"');
+  });
+});