@lenne.tech/nest-server 11.32.4 → 11.33.1

package/src/core/modules/hub/helpers/hub-mermaid.helper.spec.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-// Value and type imports are deliberately split into two statements. The lt CLI's vendor
-// conversion drops an INLINE `type` specifier from a mixed import — `{ buildErDiagram, type
-// HubModelDescriptor }` arrives in a vendored project as `{ buildErDiagram }`, and the file then
-// fails to compile with TS2304. Keeping the two forms separate survives the conversion.
-// (The CLI defect is tracked separately; this keeps src/core/ vendor-safe meanwhile.)
-import type { HubModelDescriptor } from './hub-mermaid.helper';
-
-import { buildErDiagram } from './hub-mermaid.helper';
-
-describe('buildErDiagram', () => {
-  const models: HubModelDescriptor[] = [
-    {
-      fields: [
-        { name: 'email', type: 'String' },
-        { name: 'age', type: 'Number' },
-        { name: 'company', ref: 'Company', type: 'ObjectId' },
-      ],
-      name: 'User',
-    },
-    {
-      fields: [{ name: 'name', type: 'String' }],
-      name: 'Company',
-    },
-  ];
-
-  it('opens an erDiagram block', () => {
-    const out = buildErDiagram(models);
-    expect(out.startsWith('erDiagram')).toBe(true);
-  });
-
-  it('emits one entity per model with its fields and types', () => {
-    const out = buildErDiagram(models);
-    expect(out).toContain('User {');
-    expect(out).toContain('Company {');
-    expect(out).toContain('String email');
-    expect(out).toContain('Number age');
-  });
-
-  it('renders a relationship for a ref field', () => {
-    const out = buildErDiagram(models);
-    expect(out).toMatch(/User \|\|--o\{ Company : company/);
-  });
-
-  it('ignores refs pointing at models that are not present', () => {
-    const out = buildErDiagram([{ fields: [{ name: 'ghost', ref: 'Missing', type: 'ObjectId' }], name: 'Solo' }]);
-    expect(out).toContain('Solo {');
-    expect(out).not.toContain('Missing');
-  });
-
-  it('sanitizes field/entity names so the diagram stays valid', () => {
-    const out = buildErDiagram([{ fields: [{ name: 'weird-field.name', type: 'String' }], name: 'Odd Name' }]);
-    expect(out).not.toContain('weird-field.name');
-    expect(out).not.toContain('Odd Name {');
-  });
-
-  it('handles an empty model list without throwing', () => {
-    expect(buildErDiagram([])).toBe('erDiagram');
-  });
-});

package/src/core/modules/hub/helpers/hub-shell.helper.spec.ts

@@ -1,106 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  buildHubCsp,
-  buildHubSecurityHeaders,
-  escapeHtml,
-  escapeJsString,
-  generateNonce,
-  injectNonce,
-} from './hub-shell.helper';
-
-describe('hub-shell.helper', () => {
-  describe('escapeHtml', () => {
-    it('escapes all five HTML-significant characters', () => {
-      expect(escapeHtml(`<img src="x" onerror='y'>&`)).toBe('&lt;img src=&quot;x&quot; onerror=&#39;y&#39;&gt;&amp;');
-    });
-
-    it('neutralizes a script-tag XSS payload', () => {
-      const out = escapeHtml('<script>alert(1)</script>');
-      expect(out).not.toContain('<script>');
-      expect(out).toContain('&lt;script&gt;');
-    });
-
-    it('handles empty / non-string-ish input', () => {
-      expect(escapeHtml('')).toBe('');
-    });
-  });
-
-  describe('escapeJsString', () => {
-    it('escapes characters that would break out of a JS string / script context', () => {
-      const out = escapeJsString(`a'b\\c</script>`);
-      expect(out).not.toContain('</script>');
-      expect(out).toContain("\\'");
-      expect(out).toContain('\\\\');
-      // The closing angle bracket must be escaped so `</script>` cannot terminate the tag.
-      expect(out).toContain('\\u003c');
-    });
-
-    it('escapes CR / LF into their JS escapes', () => {
-      const out = escapeJsString('line1\r\nline2');
-      expect(out).toBe('line1\\r\\nline2');
-    });
-
-    it('escapes U+2028 / U+2029, which are line terminators inside a JS string literal', () => {
-      // Built via fromCharCode so this test file stays pure ASCII (a literal separator would itself
-      // terminate the source line). A raw U+2028 in a `'...'` literal is a syntax error at runtime.
-      const lineSep = String.fromCharCode(0x2028);
-      const paraSep = String.fromCharCode(0x2029);
-      const out = escapeJsString(`before${lineSep}mid${paraSep}after`);
-      expect(out).toContain('\\u2028');
-      expect(out).toContain('\\u2029');
-      expect(out).not.toContain(lineSep);
-      expect(out).not.toContain(paraSep);
-      // The escaped result must be a valid single-line JS string literal.
-      expect(() => new Function(`return '${out}';`)()).not.toThrow();
-      expect(new Function(`return '${out}';`)()).toBe(`before${lineSep}mid${paraSep}after`);
-    });
-  });
-
-  describe('generateNonce', () => {
-    it('produces a non-empty base64 nonce that differs each call', () => {
-      const a = generateNonce();
-      const b = generateNonce();
-      expect(a.length).toBeGreaterThan(10);
-      expect(a).not.toBe(b);
-    });
-  });
-
-  describe('injectNonce', () => {
-    it('replaces every __CSP_NONCE__ placeholder', () => {
-      const html = `<style nonce="__CSP_NONCE__"></style><script nonce="__CSP_NONCE__"></script>`;
-      const out = injectNonce(html, 'abc123');
-      expect(out).not.toContain('__CSP_NONCE__');
-      expect(out).toContain('nonce="abc123"');
-      expect((out.match(/abc123/g) ?? []).length).toBe(2);
-    });
-  });
-
-  describe('buildHubCsp', () => {
-    it('is a strict, self-contained policy pinned to the nonce', () => {
-      const csp = buildHubCsp('nonce123');
-      expect(csp).toContain("default-src 'none'");
-      expect(csp).toContain("script-src 'nonce-nonce123'");
-      expect(csp).toContain("frame-ancestors 'none'");
-      expect(csp).not.toContain('unsafe-inline');
-    });
-  });
-
-  describe('buildHubSecurityHeaders', () => {
-    it('returns the strict header set with no-store for HTML by default', () => {
-      const headers = buildHubSecurityHeaders('n1');
-      expect(headers['Content-Security-Policy']).toContain('nonce-n1');
-      expect(headers['X-Frame-Options']).toBe('DENY');
-      expect(headers['X-Content-Type-Options']).toBe('nosniff');
-      expect(headers['Referrer-Policy']).toBe('no-referrer');
-      expect(headers['Cache-Control']).toContain('no-store');
-    });
-
-    it('uses a long-lived immutable cache for the cacheable script bundle', () => {
-      const headers = buildHubSecurityHeaders('n1', { cacheable: true });
-      expect(headers['Cache-Control']).toContain('max-age');
-      expect(headers['Cache-Control']).toContain('immutable');
-      expect(headers['Cache-Control']).not.toContain('no-store');
-    });
-  });
-});

package/src/core/modules/hub/hub-config.helper.spec.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { isHubEnabled, isHubQueriesEnabled, normalizeHubConfig } from './hub-config.helper';
-
-describe('hub-config.helper', () => {
-  describe('isHubEnabled', () => {
-    it('is disabled by default (undefined)', () => {
-      expect(isHubEnabled(undefined)).toBe(false);
-      expect(isHubEnabled(false)).toBe(false);
-    });
-
-    it('is enabled for true / {} / a config object', () => {
-      expect(isHubEnabled(true)).toBe(true);
-      expect(isHubEnabled({})).toBe(true);
-      expect(isHubEnabled({ path: 'x' })).toBe(true);
-    });
-
-    it('respects explicit { enabled: false }', () => {
-      expect(isHubEnabled({ enabled: false, path: 'x' })).toBe(false);
-    });
-  });
-
-  describe('isHubQueriesEnabled', () => {
-    it('is off by default even when the hub is enabled', () => {
-      expect(isHubQueriesEnabled(true)).toBe(false);
-      expect(isHubQueriesEnabled({})).toBe(false);
-    });
-
-    it('is on when queries collector is explicitly enabled', () => {
-      expect(isHubQueriesEnabled({ collectors: { queries: true } })).toBe(true);
-      expect(isHubQueriesEnabled({ collectors: { queries: { warnMs: 5 } } })).toBe(true);
-      expect(isHubQueriesEnabled({ collectors: { queries: { enabled: false } } })).toBe(false);
-    });
-
-    it('is off when the hub itself is disabled', () => {
-      expect(isHubQueriesEnabled(false)).toBe(false);
-      expect(isHubQueriesEnabled({ collectors: { queries: true }, enabled: false })).toBe(false);
-    });
-  });
-
-  describe('normalizeHubConfig', () => {
-    it('applies defaults for the boolean-true form', () => {
-      const cfg = normalizeHubConfig(true, { env: 'local', version: '1.2.3' });
-
-      expect(cfg.path).toBe('hub');
-      expect(cfg.roles).toEqual(['admin']);
-      expect(cfg.actions).toBe(true);
-      expect(cfg.pollIntervalMs).toBe(5000);
-      expect(cfg.env).toBe('local');
-      expect(cfg.version).toBe('1.2.3');
-      // Default collectors: logs + traces on, queries off.
-      expect(cfg.collectors.logs).not.toBe(false);
-      expect(cfg.collectors.traces).not.toBe(false);
-      expect(cfg.collectors.queries).toBe(false);
-    });
-
-    it('clamps the poll interval to the minimum', () => {
-      const cfg = normalizeHubConfig({ pollIntervalMs: 10 }, { env: 'local', version: '1' });
-      expect(cfg.pollIntervalMs).toBe(1000);
-    });
-
-    it('normalizes a single role string to an array', () => {
-      const cfg = normalizeHubConfig({ roles: 'S_USER' }, { env: 'local', version: '1' });
-      expect(cfg.roles).toEqual(['S_USER']);
-    });
-
-    it('keeps roles: false (opt-out of auth)', () => {
-      const cfg = normalizeHubConfig({ roles: false }, { env: 'local', version: '1' });
-      expect(cfg.roles).toBe(false);
-    });
-
-    it('resolves the queries collector with thresholds when enabled', () => {
-      const cfg = normalizeHubConfig({ collectors: { queries: { warnMs: 5 } } }, { env: 'local', version: '1' });
-      expect(cfg.collectors.queries).not.toBe(false);
-      if (cfg.collectors.queries) {
-        expect(cfg.collectors.queries.warnMs).toBe(5);
-        expect(cfg.collectors.queries.criticalMs).toBe(200);
-        expect(cfg.collectors.queries.capacity).toBe(500);
-      }
-    });
-
-    it('defaults the mailbox to disabled but enables it with capture mode when present', () => {
-      expect(normalizeHubConfig({}, { env: 'local', version: '1' }).mailbox).toBe(false);
-
-      const cfg = normalizeHubConfig({ mailbox: true }, { env: 'local', version: '1' });
-      expect(cfg.mailbox).not.toBe(false);
-      if (cfg.mailbox) {
-        expect(cfg.mailbox.mode).toBe('capture');
-        expect(cfg.mailbox.capacity).toBe(100);
-      }
-    });
-
-    it('resolves default external links', () => {
-      const cfg = normalizeHubConfig(
-        {},
-        { env: 'local', graphQlEnabled: true, permissionsPath: 'permissions', version: '1' },
-      );
-      expect(cfg.links.swagger).toBe('/swagger');
-      expect(cfg.links.graphql).toBe('/graphql');
-      expect(cfg.links.permissions).toBe('/permissions');
-    });
-
-    it('omits the graphql link when GraphQL is disabled', () => {
-      const cfg = normalizeHubConfig({}, { env: 'local', graphQlEnabled: false, version: '1' });
-      expect(cfg.links.graphql).toBeUndefined();
-    });
-  });
-});

package/src/core/modules/hub/hub-ring-buffer.spec.ts

@@ -1,95 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { HubRingBuffer } from './hub-ring-buffer';
-
-interface TestEntry {
-  seq: number;
-  timestamp: number;
-  value: string;
-}
-
-describe('HubRingBuffer', () => {
-  it('assigns monotonic sequence numbers and a timestamp', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    const a = buffer.add({ value: 'a' });
-    const b = buffer.add({ value: 'b' });
-
-    expect(a.seq).toBe(0);
-    expect(b.seq).toBe(1);
-    expect(typeof a.timestamp).toBe('number');
-    expect(b.seq).toBeGreaterThan(a.seq);
-  });
-
-  it('honors an explicitly provided timestamp', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    const entry = buffer.add({ timestamp: 123456, value: 'a' });
-
-    expect(entry.timestamp).toBe(123456);
-  });
-
-  it('evicts the oldest entries once capacity is exceeded (fixed memory)', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    for (const value of ['a', 'b', 'c', 'd', 'e']) {
-      buffer.add({ value });
-    }
-
-    const items = buffer.recent();
-    expect(items.map((i) => i.value)).toEqual(['c', 'd', 'e']);
-    expect(buffer.size).toBe(3);
-  });
-
-  it('recent(limit) returns the newest N entries, oldest→newest', () => {
-    const buffer = new HubRingBuffer<TestEntry>(5);
-    for (const value of ['a', 'b', 'c', 'd']) {
-      buffer.add({ value });
-    }
-
-    expect(buffer.recent(2).map((i) => i.value)).toEqual(['c', 'd']);
-  });
-
-  it('since(seq) returns only entries newer than the cursor', () => {
-    const buffer = new HubRingBuffer<TestEntry>(10);
-    buffer.add({ value: 'a' }); // seq 0
-    const b = buffer.add({ value: 'b' }); // seq 1
-    buffer.add({ value: 'c' }); // seq 2
-
-    expect(buffer.since(b.seq).map((i) => i.value)).toEqual(['c']);
-    expect(buffer.since(-1).map((i) => i.value)).toEqual(['a', 'b', 'c']);
-    expect(buffer.since(buffer.lastSeq)).toEqual([]);
-  });
-
-  it('since(seq) clamps to what is still retained after eviction', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    for (const value of ['a', 'b', 'c', 'd', 'e']) {
-      buffer.add({ value }); // seqs 0..4, only 2,3,4 retained
-    }
-
-    // Asking since an evicted cursor (seq 0) returns only what survives, no crash, no duplicates.
-    expect(buffer.since(0).map((i) => i.value)).toEqual(['c', 'd', 'e']);
-    expect(buffer.firstRetainedSeq).toBe(2);
-  });
-
-  it('exposes lastSeq (-1 when empty) and firstRetainedSeq', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    expect(buffer.lastSeq).toBe(-1);
-    expect(buffer.firstRetainedSeq).toBe(-1);
-    expect(buffer.size).toBe(0);
-
-    buffer.add({ value: 'a' });
-    expect(buffer.lastSeq).toBe(0);
-    expect(buffer.firstRetainedSeq).toBe(0);
-  });
-
-  it('clear() empties the buffer but keeps the sequence counter monotonic', () => {
-    const buffer = new HubRingBuffer<TestEntry>(3);
-    buffer.add({ value: 'a' });
-    buffer.add({ value: 'b' });
-    buffer.clear();
-
-    expect(buffer.size).toBe(0);
-    expect(buffer.recent()).toEqual([]);
-    // A new entry after clear must not reuse an old seq (cursors stay valid across a clear).
-    const c = buffer.add({ value: 'c' });
-    expect(c.seq).toBe(2);
-  });
-});

package/src/core/modules/hub/services/core-hub-mailbox.service.spec.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { CoreHubMailboxService } from './core-hub-mailbox.service';
-import { ResolvedHubConfig } from '../interfaces/hub-config.interface';
-
-function makeConfig(overrides: Partial<ResolvedHubConfig> = {}): ResolvedHubConfig {
-  return {
-    actions: true,
-    allowPublicAccessInProduction: false,
-    collectors: { logs: false, queries: false, traces: false },
-    db: false,
-    emailPreview: true,
-    env: 'local',
-    links: {},
-    loginEndpoint: '/iam/sign-in/email',
-    logoutEndpoint: '/iam/sign-out',
-    mailbox: { capacity: 3, maxMailSize: 100, mode: 'capture' },
-    migrations: false,
-    path: 'hub',
-    pollIntervalMs: 5000,
-    roles: ['admin'],
-    version: '1.0.0',
-    ...overrides,
-  };
-}
-
-describe('CoreHubMailboxService', () => {
-  it('captures a mail and returns true to skip transport in capture mode', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    const skip = service.capture({ html: '<b>hi</b>', subject: 'Hello', to: 'a@b.com' });
-
-    expect(skip).toBe(true);
-    const data = service.getMailbox();
-    expect(data.mode).toBe('capture');
-    expect(data.mails).toHaveLength(1);
-    expect(data.mails[0].subject).toBe('Hello');
-    expect(data.mails[0].to).toBe('a@b.com');
-    expect(data.mails[0].hasHtml).toBe(true);
-  });
-
-  it('returns false in copy mode (mail is still sent)', () => {
-    const service = new CoreHubMailboxService(makeConfig({ mailbox: { capacity: 3, maxMailSize: 100, mode: 'copy' } }));
-    const skip = service.capture({ subject: 'Copy', to: 'a@b.com' });
-
-    expect(skip).toBe(false);
-    expect(service.getMailbox().mails).toHaveLength(1);
-  });
-
-  it('redacts tokens from the stored body in COPY mode (the real mail was still delivered)', () => {
-    const service = new CoreHubMailboxService(
-      makeConfig({ mailbox: { capacity: 3, maxMailSize: 5000, mode: 'copy' } }),
-    );
-    const seq = service.captureAndGetSeq({
-      html: '<a href="https://app.example.com/reset?token=SUPERSECRETVALUE123">Reset</a>',
-      subject: 'Reset',
-      to: 'a@b.com',
-    });
-    const html = service.getMailHtml(seq);
-    expect(html).toBeDefined();
-    // The captured audit copy must not expose a replayable reset token.
-    expect(html).not.toContain('SUPERSECRETVALUE123');
-  });
-
-  it('keeps the raw body in CAPTURE mode (dev/test needs the clickable link; nothing was sent)', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    const seq = service.captureAndGetSeq({
-      html: '<a href="https://app.example.com/reset?token=SUPERSECRETVALUE123">Reset</a>',
-      subject: 'Reset',
-      to: 'a@b.com',
-    });
-    expect(service.getMailHtml(seq)).toContain('SUPERSECRETVALUE123');
-  });
-
-  it('evicts old mails beyond capacity (ring buffer)', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    for (const n of [1, 2, 3, 4, 5]) {
-      service.capture({ subject: `Mail ${n}`, to: 'a@b.com' });
-    }
-    const data = service.getMailbox();
-    expect(data.mails).toHaveLength(3);
-    expect(data.mails.map((m) => m.subject)).toEqual(['Mail 3', 'Mail 4', 'Mail 5']);
-  });
-
-  it('truncates oversized bodies to the per-mail cap', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    const big = 'x'.repeat(500);
-    const seq = service.captureAndGetSeq({ html: big, subject: 'Big', to: 'a@b.com' });
-    const html = service.getMailHtml(seq);
-    expect(html).toBeDefined();
-    expect((html as string).length).toBeLessThanOrEqual(100 + 40); // cap + truncation marker
-  });
-
-  it('serves stored HTML by seq for the preview iframe', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    const seq = service.captureAndGetSeq({ html: '<p>Body</p>', subject: 'S', to: 'a@b.com' });
-    expect(service.getMailHtml(seq)).toContain('<p>Body</p>');
-    expect(service.getMailHtml(9999)).toBeUndefined();
-  });
-
-  it('clear() empties the mailbox', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    service.capture({ subject: 'S', to: 'a@b.com' });
-    service.clear();
-    expect(service.getMailbox().mails).toHaveLength(0);
-  });
-
-  it('supports cursor-based polling via since', () => {
-    const service = new CoreHubMailboxService(makeConfig());
-    service.capture({ subject: 'A', to: 'a@b.com' });
-    const first = service.getMailbox();
-    service.capture({ subject: 'B', to: 'a@b.com' });
-    const next = service.getMailbox(first.cursor);
-    expect(next.mails).toHaveLength(1);
-    expect(next.mails[0].subject).toBe('B');
-  });
-});

package/src/core/modules/hub/services/hub-trace-buffer.service.spec.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { HubTraceBufferService } from './hub-trace-buffer.service';
-import { ResolvedHubConfig } from '../interfaces/hub-config.interface';
-
-function makeConfig(overrides: Partial<ResolvedHubConfig> = {}): ResolvedHubConfig {
-  return {
-    actions: true,
-    allowPublicAccessInProduction: false,
-    collectors: {
-      logs: false,
-      queries: false,
-      traces: { capacity: 50, captureGraphQlOperation: true, excludePaths: [], slowMs: 1000 },
-    },
-    db: false,
-    emailPreview: true,
-    env: 'local',
-    links: {},
-    loginEndpoint: '/iam/sign-in/email',
-    logoutEndpoint: '/iam/sign-out',
-    mailbox: false,
-    migrations: false,
-    path: 'hub',
-    pollIntervalMs: 5000,
-    roles: ['admin'],
-    version: '1.0.0',
-    ...overrides,
-  };
-}
-
-/** Minimal Express req/res doubles for record(). */
-function reqRes(path: string, method = 'GET', statusCode = 200) {
-  return {
-    req: { baseUrl: '', method, path, route: undefined } as never,
-    res: { getHeader: () => undefined, statusCode, writableFinished: true } as never,
-  };
-}
-
-describe('HubTraceBufferService', () => {
-  describe('isExcluded (boundary-aware)', () => {
-    it('excludes the Hub base path and its sub-paths', () => {
-      const service = new HubTraceBufferService(makeConfig());
-      expect(service.isExcluded('/hub')).toBe(true);
-      expect(service.isExcluded('/hub/logs.json')).toBe(true);
-      expect(service.isExcluded('/hub/actions/collectors/traces/clear')).toBe(true);
-    });
-
-    it('does NOT exclude a sibling route that merely shares the prefix string', () => {
-      const service = new HubTraceBufferService(makeConfig());
-      // Regression guard for the over-broad `startsWith(prefix)` bug: `/hubble` is not a Hub route.
-      expect(service.isExcluded('/hubble')).toBe(false);
-      expect(service.isExcluded('/hub-admin')).toBe(false);
-      expect(service.isExcluded('/hubbard/x')).toBe(false);
-    });
-
-    it('honours additional configured exclude prefixes with the same boundary rule', () => {
-      const service = new HubTraceBufferService(
-        makeConfig({
-          collectors: {
-            logs: false,
-            queries: false,
-            traces: { capacity: 50, captureGraphQlOperation: true, excludePaths: ['/health'], slowMs: 1000 },
-          },
-        }),
-      );
-      expect(service.isExcluded('/health')).toBe(true);
-      expect(service.isExcluded('/health/live')).toBe(true);
-      expect(service.isExcluded('/healthcheck')).toBe(false);
-    });
-  });
-
-  describe('record + getData', () => {
-    it('records a completed request with method, path and duration, and summarises', () => {
-      const service = new HubTraceBufferService(makeConfig());
-      const { req, res } = reqRes('/permissions/json');
-      service.record(req, res, 12.5, false, '/permissions/json');
-
-      const data = service.getData();
-      expect(data.traces).toHaveLength(1);
-      expect(data.traces[0].method).toBe('GET');
-      expect(data.traces[0].path).toBe('/permissions/json');
-      expect(data.traces[0].durationMs).toBe(12.5);
-      expect(data.summary.total).toBe(1);
-      expect(data.summary.avgMs).toBe(12.5);
-    });
-
-    it('flags slow and error traces in the summary', () => {
-      const service = new HubTraceBufferService(makeConfig());
-      const slow = reqRes('/slow');
-      service.record(slow.req, slow.res, 5000, false, '/slow');
-      const err = reqRes('/boom', 'GET', 500);
-      service.record(err.req, err.res, 3, false, '/boom');
-
-      const data = service.getData();
-      expect(data.summary.slowCount).toBe(1);
-      expect(data.summary.errorCount).toBe(1);
-    });
-
-    it('supports cursor-based polling via since', () => {
-      const service = new HubTraceBufferService(makeConfig());
-      const a = reqRes('/a');
-      service.record(a.req, a.res, 1, false, '/a');
-      const cursor = service.getData().cursor;
-      const b = reqRes('/b');
-      service.record(b.req, b.res, 2, false, '/b');
-
-      const next = service.getData(cursor);
-      expect(next.traces).toHaveLength(1);
-      expect(next.traces[0].path).toBe('/b');
-    });
-  });
-});