cds-error-outbox 1.0.0 → 1.0.2

package/tests/dedup.test.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { createHash, upsertError } = require('../lib/dedup');
+
+// ── createHash ───────────────────────────────────────────────────────────────
+
+describe('createHash', () => {
+  it('returns a 64-character hex string', () => {
+    const hash = createHash('err', 'svc', 'READ');
+    assert.equal(typeof hash, 'string');
+    assert.equal(hash.length, 64);
+    assert.match(hash, /^[0-9a-f]{64}$/);
+  });
+
+  it('is deterministic — same inputs produce same hash', () => {
+    const a = createHash('boom', 'TestService', 'READ');
+    const b = createHash('boom', 'TestService', 'READ');
+    assert.equal(a, b);
+  });
+
+  it('produces different hashes for different inputs', () => {
+    const a = createHash('boom', 'TestService', 'READ');
+    const b = createHash('boom', 'TestService', 'WRITE');
+    assert.notEqual(a, b);
+  });
+});
+
+// ── upsertError — DB mock helpers ────────────────────────────────────────────
+
+function makeDb({ existing = null } = {}) {
+  const ops = [];
+
+  return {
+    ops,
+    run: async (query) => {
+      ops.push(query);
+      // SELECT returns existing record or empty
+      if (query && query._SELECT) return existing ? [existing] : [];
+      return {};
+    }
+  };
+}
+
+// CDS query builders produce objects with internal symbols — we use a thin shim
+// so the tests don't depend on @sap/cds internals.
+// We patch SELECT/INSERT/UPDATE on global before each group.
+
+function installCdsGlobals() {
+  const crypto = require('crypto');
+
+  // Minimal SELECT shim
+  global.SELECT = {
+    from: (entity) => ({
+      _SELECT: true,
+      _entity: entity,
+      where: function (c) { this._where = c; return this; },
+      and: function (c, v) { this._and = [c, v]; return this; },
+      limit: function (n) { this._limit = n; return this; }
+    })
+  };
+
+  global.INSERT = {
+    into: (entity) => ({
+      entries: (data) => ({ _INSERT: true, _entity: entity, _data: data })
+    })
+  };
+
+  global.UPDATE = (entity) => ({
+    _UPDATE: true,
+    _entity: entity,
+    set: function (d) { this._set = d; return this; },
+    where: function (c) { this._where = c; return this; }
+  });
+}
+
+// ── upsertError — inserts ────────────────────────────────────────────────────
+
+describe('upsertError — new error', () => {
+  installCdsGlobals();
+
+  const config = {
+    dedup: { enabled: true, windowMinutes: 10 }
+  };
+
+  it('inserts a new record when no existing error is found', async () => {
+    const db = makeDb({ existing: null });
+    await upsertError(db, { message: 'boom', stack: 'at x', service: 'Svc', action: 'READ' }, config);
+
+    const insert = db.ops.find(o => o._INSERT);
+    assert.ok(insert, 'expected an INSERT operation');
+    assert.equal(insert._data.message, 'boom');
+    assert.equal(insert._data.service, 'Svc');
+    assert.equal(insert._data.action, 'READ');
+    assert.equal(insert._data.count, 1);
+    assert.equal(insert._data.sent, false);
+  });
+
+  it('sets service/action to "unknown" when missing', async () => {
+    const db = makeDb({ existing: null });
+    await upsertError(db, { message: 'boom', stack: '' }, config);
+
+    const insert = db.ops.find(o => o._INSERT);
+    assert.equal(insert._data.service, 'unknown');
+    assert.equal(insert._data.action, 'unknown');
+  });
+
+  it('truncates message to 5000 characters', async () => {
+    const long = 'x'.repeat(6000);
+    const db = makeDb({ existing: null });
+    await upsertError(db, { message: long, stack: '', service: 'S', action: 'A' }, config);
+
+    const insert = db.ops.find(o => o._INSERT);
+    assert.equal(insert._data.message.length, 5000);
+  });
+
+  it('truncates stack to 10000 characters', async () => {
+    const long = 'x'.repeat(12000);
+    const db = makeDb({ existing: null });
+    await upsertError(db, { message: 'err', stack: long, service: 'S', action: 'A' }, config);
+
+    const insert = db.ops.find(o => o._INSERT);
+    assert.equal(insert._data.stack.length, 10000);
+  });
+
+  it('inserts a new record when dedup is disabled (ignores existing)', async () => {
+    const existing = { ID: 'abc', count: 3, hash: 'x' };
+    const db = makeDb({ existing });
+    const cfg = { dedup: { enabled: false, windowMinutes: 10 } };
+    await upsertError(db, { message: 'boom', stack: '', service: 'S', action: 'A' }, cfg);
+
+    const insert = db.ops.find(o => o._INSERT);
+    assert.ok(insert, 'expected INSERT even when existing record present');
+  });
+});
+
+// ── upsertError — updates (dedup) ────────────────────────────────────────────
+
+describe('upsertError — dedup update', () => {
+  installCdsGlobals();
+
+  const config = {
+    dedup: { enabled: true, windowMinutes: 10 }
+  };
+
+  it('updates count and lastSeen when a matching error exists', async () => {
+    const existing = { ID: 'existing-id', count: 2, hash: 'somehash' };
+    const db = makeDb({ existing });
+    await upsertError(db, { message: 'boom', stack: '', service: 'S', action: 'A' }, config);
+
+    const update = db.ops.find(o => o._UPDATE);
+    assert.ok(update, 'expected an UPDATE operation');
+    assert.equal(update._set.count, 3);
+    assert.ok(update._set.lastSeen, 'lastSeen should be updated');
+    assert.equal(update._where.ID, 'existing-id');
+  });
+});

package/tests/formatter.test.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { escapeHtml, formatHtmlEmail } = require('../lib/formatter');
+
+// ── escapeHtml ───────────────────────────────────────────────────────────────
+
+describe('escapeHtml', () => {
+  it('escapes &', () => assert.equal(escapeHtml('a&b'), 'a&b'));
+  it('escapes <', () => assert.equal(escapeHtml('a<b'), 'a&lt;b'));
+  it('escapes >', () => assert.equal(escapeHtml('a>b'), 'a&gt;b'));
+  it('escapes "', () => assert.equal(escapeHtml('a"b'), 'a&quot;b'));
+  it("escapes '", () => assert.equal(escapeHtml("a'b"), 'a&#039;b'));
+  it('leaves plain strings unchanged', () => assert.equal(escapeHtml('hello world'), 'hello world'));
+  it('escapes multiple characters in one string', () => {
+    assert.equal(escapeHtml('<script>alert("xss")</script>'), '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+  });
+});
+
+// ── formatHtmlEmail ──────────────────────────────────────────────────────────
+
+function makeError(overrides = {}) {
+  return {
+    ID: 'id-1',
+    service: 'TestService',
+    action: 'READ',
+    message: 'Something went wrong',
+    stack: 'Error: Something went wrong\n  at handler (srv.js:10)\n  at next (cds.js:5)',
+    count: 1,
+    firstSeen: '2026-06-02T10:00:00.000Z',
+    lastSeen: '2026-06-02T10:05:00.000Z',
+    sent: false,
+    ...overrides
+  };
+}
+
+describe('formatHtmlEmail', () => {
+  it('returns subject and html keys', () => {
+    const { subject, html } = formatHtmlEmail([makeError()]);
+    assert.equal(typeof subject, 'string');
+    assert.equal(typeof html, 'string');
+  });
+
+  it('subject contains error count and occurrence count', () => {
+    const errors = [makeError({ count: 3 }), makeError({ ID: 'id-2', count: 2 })];
+    const { subject } = formatHtmlEmail(errors);
+    assert.match(subject, /5 occurrence\(s\)/);
+    assert.match(subject, /2 error\(s\)/);
+  });
+
+  it('html contains service name', () => {
+    const { html } = formatHtmlEmail([makeError({ service: 'BookshopService' })]);
+    assert.ok(html.includes('BookshopService'), 'expected service name in HTML');
+  });
+
+  it('html contains escaped message', () => {
+    const { html } = formatHtmlEmail([makeError({ message: '<script>xss</script>' })]);
+    assert.ok(html.includes('&lt;script&gt;'), 'message should be HTML-escaped');
+    assert.ok(!html.includes('<script>xss</script>'), 'raw script tag must not appear');
+  });
+
+  it('groups errors by service', () => {
+    const errors = [
+      makeError({ ID: '1', service: 'ServiceA', message: 'err A' }),
+      makeError({ ID: '2', service: 'ServiceB', message: 'err B' })
+    ];
+    const { html } = formatHtmlEmail(errors);
+    assert.ok(html.includes('ServiceA'));
+    assert.ok(html.includes('ServiceB'));
+  });
+
+  it('stack trace is included in the email', () => {
+    const err = makeError({ stack: 'line1\nline2\nline3\nline4\nline5\nline6\nline7' });
+    const { html } = formatHtmlEmail([err]);
+    assert.ok(html.includes('line1'));
+    // Only first 5 lines should appear
+    assert.ok(!html.includes('line6'), 'stack should be truncated to 5 lines');
+  });
+
+  it('handles empty errors array without throwing', () => {
+    assert.doesNotThrow(() => formatHtmlEmail([]));
+  });
+
+  it('handles missing optional fields gracefully', () => {
+    const minimal = { ID: 'x', service: 'S', action: 'A', message: 'oops', count: 1 };
+    assert.doesNotThrow(() => formatHtmlEmail([minimal]));
+  });
+});

package/tests/scheduler.test.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+// Load @sap/cds first — this installs SELECT/INSERT/UPDATE globals (read-only)
+const cds = require('@sap/cds');
+
+const { start, stop, runBatch } = require('../lib/scheduler');
+
+// ── DB mock factory ───────────────────────────────────────────────────────────
+// runBatch calls cds.connect.to('db') — we replace that with a fake that
+// returns a controlled db object. The global SELECT/UPDATE are used by the
+// production code, so we let them be; we only track what db.run receives.
+
+function makeDb({ errors = [] } = {}) {
+  const ops = [];
+  const db = {
+    ops,
+    run: async (query) => {
+      // Detect SELECT vs UPDATE by inspecting the query object CAP builds.
+      // A SELECT query has a .SELECT property; an UPDATE has .UPDATE.
+      if (query && query.SELECT) return errors;
+      ops.push(query);
+      return {};
+    }
+  };
+  return db;
+}
+
+function mockConnect(db) {
+  // cds.connect is a read-only getter, but cds.connect.to is a regular property
+  // we can replace on the existing object.
+  const orig = cds.connect.to;
+  cds.connect.to = async () => db;
+  return () => { cds.connect.to = orig; }; // returns restore function
+}
+
+function mockConnectFail() {
+  const orig = cds.connect.to;
+  cds.connect.to = async () => { throw new Error('DB connection failed'); };
+  return () => { cds.connect.to = orig; };
+}
+
+afterEach(() => {
+  stop();
+});
+
+// ── start / stop ─────────────────────────────────────────────────────────────
+
+describe('start / stop', () => {
+  it('start returns a truthy handle', () => {
+    const config = { interval: 60000, batchSize: 10 };
+    const provider = { send: async () => {} };
+    const handle = start(config, provider);
+    assert.ok(handle, 'expected a truthy handle');
+    stop();
+  });
+
+  it('stop does not throw when scheduler is not running', () => {
+    stop();
+    assert.doesNotThrow(() => stop());
+  });
+
+  it('calling start twice replaces the existing interval', () => {
+    const config = { interval: 60000, batchSize: 10 };
+    const provider = { send: async () => {} };
+    const h1 = start(config, provider);
+    const h2 = start(config, provider);
+    assert.notEqual(h1, h2);
+    stop();
+  });
+});
+
+// ── runBatch — empty queue ────────────────────────────────────────────────────
+
+describe('runBatch — empty queue', () => {
+  it('does nothing when there are no unsent errors', async () => {
+    const db = makeDb({ errors: [] });
+    const restore = mockConnect(db);
+    const provider = { send: async () => { throw new Error('should not be called'); } };
+    const config = { batchSize: 10, mail: {} };
+    try {
+      await assert.doesNotReject(() => runBatch(config, provider));
+      assert.equal(db.ops.length, 0, 'no UPDATE should occur');
+    } finally { restore(); }
+  });
+});
+
+// ── runBatch — successful send ────────────────────────────────────────────────
+
+describe('runBatch — successful send', () => {
+  it('calls provider.send and marks errors as sent', async () => {
+    const now = new Date().toISOString();
+    const errors = [
+      { ID: 'id-1', service: 'S', action: 'A', message: 'boom', count: 1, sent: false, firstSeen: now, lastSeen: now },
+      { ID: 'id-2', service: 'S', action: 'A', message: 'crash', count: 1, sent: false, firstSeen: now, lastSeen: now }
+    ];
+    const db = makeDb({ errors });
+    const restore = mockConnect(db);
+
+    let sendCalled = false;
+    const provider = { send: async () => { sendCalled = true; } };
+    const config = { batchSize: 10, mail: {} };
+    try {
+      await runBatch(config, provider);
+
+      assert.ok(sendCalled, 'provider.send should have been called');
+      assert.ok(db.ops.length > 0, 'expected UPDATE to mark errors as sent');
+      const update = db.ops[0];
+      assert.ok(update && update.UPDATE, 'expected an UPDATE query');
+    } finally { restore(); }
+  });
+});
+
+// ── runBatch — send failure ───────────────────────────────────────────────────
+
+describe('runBatch — send failure', () => {
+  it('does NOT mark errors as sent when provider.send throws', async () => {
+    const now = new Date().toISOString();
+    const errors = [
+      { ID: 'id-1', service: 'S', action: 'A', message: 'boom', count: 1, sent: false, firstSeen: now, lastSeen: now }
+    ];
+    const db = makeDb({ errors });
+    const restore = mockConnect(db);
+
+    const provider = { send: async () => { throw new Error('SMTP timeout'); } };
+    const config = { batchSize: 10, mail: {} };
+    try {
+      await runBatch(config, provider);
+      assert.equal(db.ops.length, 0, 'errors must NOT be marked sent when send fails');
+    } finally { restore(); }
+  });
+});
+
+// ── runBatch — DB failure ─────────────────────────────────────────────────────
+
+describe('runBatch — DB failure', () => {
+  it('does not throw when DB connection fails', async () => {
+    const restore = mockConnectFail();
+    const provider = { send: async () => {} };
+    const config = { batchSize: 10, mail: {} };
+    try {
+      await assert.doesNotReject(() => runBatch(config, provider));
+    } finally { restore(); }
+  });
+});