@yarkivaev/source-to-sink 1.1.0 → 1.2.2

package/test/integration_lokiSource.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import { describe, it, before, after } from 'mocha';
+import { after, before, describe, it } from 'mocha';
 import { GenericContainer } from 'testcontainers';
 import lokiSource from '../src/lokiSource.js';
 import clock from '../src/clock.js';
@@ -50,7 +50,7 @@ describe('lokiSource integration', function() {
         // Loki not ready yet
       }
       retries -= 1;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await new Promise((resolve) => { setTimeout(resolve, 1000); });
     }
   });
 
@@ -65,13 +65,13 @@ describe('lokiSource integration', function() {
     this.timeout(30000);
     const received = [];
     const app = `app${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (entry) => received.push(entry) };
+    const collector = { accept: (entry) => {return received.push(entry)} };
     const clk = clock();
     const source = lokiSource(url, `{app="${app}"}`, 0.5, collector, clk);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve) => { setTimeout(resolve, 500); });
     await pushToLoki(url, { app }, `test entry ${Math.random()}`);
-    await new Promise((resolve) => setTimeout(resolve, 3000));
+    await new Promise((resolve) => { setTimeout(resolve, 3000); });
     source.stop();
     assert.strictEqual(received.length >= 1, true, 'Should receive entries from Loki');
   });
@@ -80,13 +80,13 @@ describe('lokiSource integration', function() {
     this.timeout(30000);
     const received = [];
     const app = `app${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (entry) => received.push(entry) };
+    const collector = { accept: (entry) => {return received.push(entry)} };
     const clk = clock();
     const source = lokiSource(url, `{app="${app}"}`, 0.5, collector, clk);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve) => { setTimeout(resolve, 500); });
     await pushToLoki(url, { app }, `тест запись ${Math.random()}`);
-    await new Promise((resolve) => setTimeout(resolve, 3000));
+    await new Promise((resolve) => { setTimeout(resolve, 3000); });
     source.stop();
     assert.strictEqual(received.length >= 1, true, 'Should receive entries with unicode');
   });
@@ -95,15 +95,15 @@ describe('lokiSource integration', function() {
     this.timeout(30000);
     const received = [];
     const app = `app${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (entry) => received.push(entry) };
+    const collector = { accept: (entry) => {return received.push(entry)} };
     const clk = clock();
     const source = lokiSource(url, `{app="${app}"}`, 0.5, collector, clk);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
-    const before = received.length;
+    const snapshot = received.length;
     await pushToLoki(url, { app }, `after stop ${Math.random()}`);
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    assert.strictEqual(received.length, before, 'Should not receive entries after stop');
+    await new Promise((resolve) => { setTimeout(resolve, 2000); });
+    assert.strictEqual(received.length, snapshot, 'Should not receive entries after stop');
   });
 });

package/test/integration_mqttSink.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import { describe, it, before, after } from 'mocha';
+import { after, before, describe, it } from 'mocha';
 import { GenericContainer } from 'testcontainers';
 import mqtt from 'mqtt';
 import mqttSink from '../src/mqttSink.js';
@@ -23,7 +23,7 @@ describe('mqttSink integration', function() {
     await new Promise((resolve, reject) => {
       subscriber.on('connect', resolve);
       subscriber.on('error', reject);
-      setTimeout(() => reject(new Error('MQTT connection timeout')), 10000);
+      setTimeout(() => { reject(new Error('MQTT connection timeout')); }, 10000);
     });
   });
 
@@ -45,13 +45,13 @@ describe('mqttSink integration', function() {
     subscriber.on('message', (t, payload) => {
       received.push({ topic: t, payload: payload.toString() });
     });
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const sink = mqttSink(url);
     sink.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const value = `${Math.random()}`;
     sink.write([{ topic, payload: value }]);
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     sink.stop();
     assert.strictEqual(received.length >= 1, true, 'Subscriber should receive published record');
   });
@@ -66,13 +66,13 @@ describe('mqttSink integration', function() {
         received.push(payload.toString());
       }
     });
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const sink = mqttSink(url);
     sink.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const text = `Данные температуры ${Math.random()}`;
     sink.write([{ topic, payload: text }]);
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     sink.stop();
     assert.strictEqual(received.length >= 1, true, 'Subscriber should receive unicode payload');
   });
@@ -87,14 +87,14 @@ describe('mqttSink integration', function() {
         received.push(payload.toString());
       }
     });
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const sink = mqttSink(url);
     sink.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     sink.stop();
     assert.throws(
-      () => sink.write([{ topic, payload: `${Math.random()}` }]),
-      /not connected/,
+      () => {return sink.write([{ topic, payload: `${Math.random()}` }])},
+      /not connected/u,
       'Should throw when writing after stop'
     );
   });

package/test/integration_mqttSource.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import { describe, it, before, after } from 'mocha';
+import { after, before, describe, it } from 'mocha';
 import { GenericContainer } from 'testcontainers';
 import mqtt from 'mqtt';
 import mqttSource from '../src/mqttSource.js';
@@ -23,7 +23,7 @@ describe('mqttSource integration', function() {
     await new Promise((resolve, reject) => {
       publisher.on('connect', resolve);
       publisher.on('error', reject);
-      setTimeout(() => reject(new Error('MQTT connection timeout')), 10000);
+      setTimeout(() => { reject(new Error('MQTT connection timeout')); }, 10000);
     });
   });
 
@@ -41,13 +41,13 @@ describe('mqttSource integration', function() {
     this.timeout(10000);
     const received = [];
     const topic = `sensors/${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (record) => received.push(record) };
+    const collector = { accept: (record) => {return received.push(record)} };
     const source = mqttSource(url, topic, collector);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const record = { value: Math.random(), unit: `\u00b0C` };
     publisher.publish(topic, JSON.stringify(record));
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
     assert.strictEqual(received.length >= 1, true, 'Should receive message from broker');
   });
@@ -56,13 +56,13 @@ describe('mqttSource integration', function() {
     this.timeout(10000);
     const received = [];
     const topic = `sensors/${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (record) => received.push(record) };
+    const collector = { accept: (record) => {return received.push(record)} };
     const source = mqttSource(url, topic, collector);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const record = { name: `Тест${Math.random()}`, value: Math.random() };
     publisher.publish(topic, JSON.stringify(record));
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
     assert.strictEqual(received.length >= 1, true, 'Should receive message with unicode');
   });
@@ -71,15 +71,15 @@ describe('mqttSource integration', function() {
     this.timeout(10000);
     const received = [];
     const topic = `sensors/${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (record) => received.push(record) };
+    const collector = { accept: (record) => {return received.push(record)} };
     const source = mqttSource(url, topic, collector);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
-    const before = received.length;
+    const snapshot = received.length;
     publisher.publish(topic, JSON.stringify({ value: Math.random() }));
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    assert.strictEqual(received.length, before, 'Should not receive messages after stop');
+    await new Promise((resolve) => { setTimeout(resolve, 500); });
+    assert.strictEqual(received.length, snapshot, 'Should not receive messages after stop');
   });
 
   it('receives messages from multiple comma separated topics', async function() {
@@ -89,13 +89,13 @@ describe('mqttSource integration', function() {
     const first = `plant/${suffix}`;
     const second = `device/${suffix}`;
     const topics = `${first},${second}`;
-    const collector = { accept: (record) => received.push(record) };
+    const collector = { accept: (record) => {return received.push(record)} };
     const source = mqttSource(url, topics, collector);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     publisher.publish(first, JSON.stringify({ source: 'first', value: Math.random() }));
     publisher.publish(second, JSON.stringify({ source: 'second', value: Math.random() }));
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
     assert.strictEqual(received.length, 2, 'Should receive messages from both topics');
   });
@@ -104,13 +104,13 @@ describe('mqttSource integration', function() {
     this.timeout(10000);
     const received = [];
     const topic = `raw/${Math.random().toString(36).slice(2)}`;
-    const collector = { accept: (record) => received.push(record) };
+    const collector = { accept: (record) => {return received.push(record)} };
     const source = mqttSource(url, topic, collector);
     source.start();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     const payload = `plain text message ${Math.random()}`;
     publisher.publish(topic, payload);
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => { setTimeout(resolve, 1000); });
     source.stop();
     assert.strictEqual(received.length, 1, 'Should receive raw message');
     assert.strictEqual(received[0].topic, topic, 'Should include topic');

package/test/test_batch.js

@@ -7,12 +7,12 @@ import fakeClock from './fakeClock.js';
 describe('batch', () => {
   it('flushes when batch size is reached', () => {
     const received = [];
-    const sink = { write: (records) => received.push(...records) };
+    const sink = { write: (records) => {return received.push(...records)} };
     const size = Math.floor(Math.random() * 5) + 2;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(5, 60, clk);
     const b = batch(sink, size, c);
-    for (let i = 0; i < size; i++) {
+    for (let i = 0; i < size; i += 1) {
       b.accept({ value: `\u00e9\u00f1\u00fc${i}` });
     }
     b.stop();
@@ -21,12 +21,12 @@ describe('batch', () => {
 
   it('flushes on manual flush call', () => {
     const received = [];
-    const sink = { write: (records) => received.push(...records) };
+    const sink = { write: (records) => {return received.push(...records)} };
     const count = Math.floor(Math.random() * 5) + 1;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(5, 60, clk);
     const b = batch(sink, 100, c);
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < count; i += 1) {
       b.accept({ id: `\u4e2d\u6587${i}` });
     }
     b.flush();
@@ -47,12 +47,12 @@ describe('batch', () => {
 
   it('clears records on stop', () => {
     const received = [];
-    const sink = { write: (records) => received.push(...records) };
+    const sink = { write: (records) => {return received.push(...records)} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(5, 60, clk);
     const b = batch(sink, 100, c);
     const count = Math.floor(Math.random() * 5) + 1;
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < count; i += 1) {
       b.accept({ x: Math.random() });
     }
     b.stop();
@@ -62,7 +62,7 @@ describe('batch', () => {
 
   it('respects circuit when allowing', () => {
     const received = [];
-    const sink = { write: (records) => received.push(...records) };
+    const sink = { write: (records) => {return received.push(...records)} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(5, 60, clk);
     const b = batch(sink, 2, c);
@@ -74,7 +74,7 @@ describe('batch', () => {
 
   it('skips flush when circuit is not allowing', () => {
     const received = [];
-    const sink = { write: (records) => received.push(...records) };
+    const sink = { write: (records) => {return received.push(...records)} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(1, 60, clk);
     c.fail();
@@ -89,7 +89,7 @@ describe('batch', () => {
     let succeeded = false;
     const sink = { write: () => {} };
     const c = {
-      allowing: () => true,
+      allowing: () => {return true},
       succeed: () => { succeeded = true; },
       fail: () => {}
     };
@@ -99,29 +99,15 @@ describe('batch', () => {
     assert.strictEqual(succeeded, true, 'Should call succeed on circuit');
   });
 
-  it('calls fail on circuit when sink throws', () => {
-    let failed = false;
-    const sink = { write: () => { throw new Error('Sink failure'); } };
-    const c = {
-      allowing: () => true,
-      succeed: () => {},
-      fail: () => { failed = true; }
-    };
-    const b = batch(sink, 1, c);
-    try { b.accept({ v: Math.random() }); } catch (e) { /* expected */ }
-    b.stop();
-    assert.strictEqual(failed, true, 'Should call fail on circuit');
-  });
-
   it('propagates error when sink throws', () => {
     const sink = { write: () => { throw new Error('Sink failure'); } };
     const c = {
-      allowing: () => true,
+      allowing: () => {return true},
       succeed: () => {},
       fail: () => {}
     };
     const b = batch(sink, 1, c);
-    assert.throws(() => b.accept({ v: Math.random() }), /Sink failure/, 'Should propagate error');
+    assert.throws(() => {return b.accept({ v: Math.random() })}, /Sink failure/u, 'Should propagate error');
   });
 
   it('preserves records after failed write', () => {
@@ -137,34 +123,34 @@ describe('batch', () => {
       }
     };
     const c = {
-      allowing: () => true,
+      allowing: () => {return true},
       succeed: () => {},
       fail: () => {}
     };
     const b = batch(sink, 100, c);
     b.accept({ data: `\u00e9${Math.random()}` });
-    try { b.flush(); } catch (e) { /* first attempt fails */ }
+    assert.throws(() => {return b.flush()}, /Temporary failure/u, 'Should throw on first attempt');
     b.flush();
     b.stop();
     assert.strictEqual(received.length, 1, 'Should preserve records after failed write');
   });
 
   it('throws on missing sink', () => {
-    const c = { allowing: () => true, succeed: () => {}, fail: () => {} };
+    const c = { allowing: () => {return true}, succeed: () => {}, fail: () => {} };
     assert.throws(
-      () => batch(null, 10, c),
-      /Sink must have a write/,
+      () => {return batch(null, 10, c)},
+      /Sink must have a write/u,
       'Should reject missing sink'
     );
   });
 
   it('throws on invalid size', () => {
     const sink = { write: () => {} };
-    const c = { allowing: () => true, succeed: () => {}, fail: () => {} };
+    const c = { allowing: () => {return true}, succeed: () => {}, fail: () => {} };
     const invalid = -Math.floor(Math.random() * 10);
     assert.throws(
-      () => batch(sink, invalid, c),
-      /Size must be a positive number/,
+      () => {return batch(sink, invalid, c)},
+      /Size must be a positive number/u,
       'Should reject invalid size'
     );
   });
@@ -172,8 +158,8 @@ describe('batch', () => {
   it('throws on missing circuit', () => {
     const sink = { write: () => {} };
     assert.throws(
-      () => batch(sink, 10),
-      /Circuit must have an allowing\(\) method/,
+      () => {return batch(sink, 10)},
+      /Circuit must have an allowing\(\) method/u,
       'Should reject missing circuit'
     );
   });

package/test/test_circuit.js

@@ -17,7 +17,7 @@ describe('circuit', () => {
     const timeout = Math.random() * 100 + 1;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(threshold, timeout, clk);
-    for (let i = 0; i < threshold - 1; i++) {
+    for (let i = 0; i < threshold - 1; i += 1) {
       c.fail();
     }
     assert.strictEqual(c.allowing(), true, 'Circuit should remain allowing below threshold');
@@ -28,7 +28,7 @@ describe('circuit', () => {
     const timeout = Math.random() * 100 + 1;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(threshold, timeout, clk);
-    for (let i = 0; i < threshold; i++) {
+    for (let i = 0; i < threshold; i += 1) {
       c.fail();
     }
     assert.strictEqual(c.allowing(), false, 'Circuit should stop allowing at threshold');
@@ -39,7 +39,7 @@ describe('circuit', () => {
     const timeout = Math.random() * 100 + 1;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(threshold, timeout, clk);
-    for (let i = 0; i < threshold - 1; i++) {
+    for (let i = 0; i < threshold - 1; i += 1) {
       c.fail();
     }
     c.succeed();
@@ -52,7 +52,7 @@ describe('circuit', () => {
     const timeout = 60;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(threshold, timeout, clk);
-    for (let i = 0; i < threshold; i++) {
+    for (let i = 0; i < threshold; i += 1) {
       c.fail();
     }
     clk.advance(timeout * 1000);
@@ -64,8 +64,8 @@ describe('circuit', () => {
     const invalid = -Math.floor(Math.random() * 10);
     const clk = fakeClock(0);
     assert.throws(
-      () => circuit(invalid, timeout, clk),
-      /Threshold must be a positive number/,
+      () => {return circuit(invalid, timeout, clk)},
+      /Threshold must be a positive number/u,
       'Should reject invalid threshold'
     );
   });
@@ -75,8 +75,8 @@ describe('circuit', () => {
     const invalid = -Math.random() * 10 - 1;
     const clk = fakeClock(0);
     assert.throws(
-      () => circuit(threshold, invalid, clk),
-      /Timeout must be a non-negative number/,
+      () => {return circuit(threshold, invalid, clk)},
+      /Timeout must be a non-negative number/u,
       'Should reject invalid timeout'
     );
   });
@@ -85,8 +85,8 @@ describe('circuit', () => {
     const threshold = Math.floor(Math.random() * 10) + 1;
     const timeout = Math.random() * 100 + 1;
     assert.throws(
-      () => circuit(threshold, timeout),
-      /Clock must have a millis\(\) method/,
+      () => {return circuit(threshold, timeout)},
+      /Clock must have a millis\(\) method/u,
       'Should reject missing clock'
     );
   });
@@ -96,12 +96,12 @@ describe('circuit', () => {
     const timeout = 60;
     const clk = fakeClock(Math.floor(Math.random() * 10000));
     const c = circuit(threshold, timeout, clk);
-    for (let i = 0; i < threshold; i++) {
+    for (let i = 0; i < threshold; i += 1) {
       c.fail();
     }
     clk.advance(timeout * 1000);
     c.allowing();
-    for (let i = 0; i < threshold - 1; i++) {
+    for (let i = 0; i < threshold - 1; i += 1) {
       c.fail();
     }
     assert.strictEqual(c.allowing(), true, 'Circuit should remain allowing after reset');

package/test/test_clickhouseSink.js

@@ -5,32 +5,32 @@ import clickhouseSink from '../src/clickhouseSink.js';
 describe('clickhouseSink', () => {
   it('throws on missing url', () => {
     assert.throws(
-      () => clickhouseSink(null, 'metrics'),
-      /URL must be a non-empty string/,
+      () => {return clickhouseSink(null, 'metrics')},
+      /URL must be a non-empty string/u,
       'Should reject missing url'
     );
   });
 
   it('throws on empty url', () => {
     assert.throws(
-      () => clickhouseSink('', 'metrics'),
-      /URL must be a non-empty string/,
+      () => {return clickhouseSink('', 'metrics')},
+      /URL must be a non-empty string/u,
       'Should reject empty url'
     );
   });
 
   it('throws on missing table', () => {
     assert.throws(
-      () => clickhouseSink('http://localhost:8123', null),
-      /Table must be a non-empty string/,
+      () => {return clickhouseSink('http://localhost:8123', null)},
+      /Table must be a non-empty string/u,
       'Should reject missing table'
     );
   });
 
   it('throws on empty table', () => {
     assert.throws(
-      () => clickhouseSink('http://localhost:8123', ''),
-      /Table must be a non-empty string/,
+      () => {return clickhouseSink('http://localhost:8123', '')},
+      /Table must be a non-empty string/u,
       'Should reject empty table'
     );
   });

package/test/test_lokiSource.js

@@ -8,8 +8,8 @@ describe('lokiSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => lokiSource(null, '{app="test"}', 10, collector, clk),
-      /URL must be a non-empty string/,
+      () => {return lokiSource(null, '{app="test"}', 10, collector, clk)},
+      /URL must be a non-empty string/u,
       'Should reject missing url'
     );
   });
@@ -18,8 +18,8 @@ describe('lokiSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => lokiSource('', '{app="test"}', 10, collector, clk),
-      /URL must be a non-empty string/,
+      () => {return lokiSource('', '{app="test"}', 10, collector, clk)},
+      /URL must be a non-empty string/u,
       'Should reject empty url'
     );
   });
@@ -28,8 +28,8 @@ describe('lokiSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => lokiSource('http://localhost:3100', '', 10, collector, clk),
-      /Query must be a non-empty string/,
+      () => {return lokiSource('http://localhost:3100', '', 10, collector, clk)},
+      /Query must be a non-empty string/u,
       'Should reject empty query'
     );
   });
@@ -38,8 +38,8 @@ describe('lokiSource', () => {
     const collector = { accept: () => {} };
     const clk = fakeClock(0);
     assert.throws(
-      () => lokiSource('http://localhost:3100', '{app="test"}', -1, collector, clk),
-      /Interval must be a positive number/,
+      () => {return lokiSource('http://localhost:3100', '{app="test"}', -1, collector, clk)},
+      /Interval must be a positive number/u,
       'Should reject invalid interval'
     );
   });
@@ -47,8 +47,8 @@ describe('lokiSource', () => {
   it('throws on missing collector', () => {
     const clk = fakeClock(0);
     assert.throws(
-      () => lokiSource('http://localhost:3100', '{app="test"}', 10, null, clk),
-      /Collector must have an accept\(\) method/,
+      () => {return lokiSource('http://localhost:3100', '{app="test"}', 10, null, clk)},
+      /Collector must have an accept\(\) method/u,
       'Should reject missing collector'
     );
   });
@@ -56,8 +56,8 @@ describe('lokiSource', () => {
   it('throws on missing clock', () => {
     const collector = { accept: () => {} };
     assert.throws(
-      () => lokiSource('http://localhost:3100', '{app="test"}', 10, collector, null),
-      /Clock must have a millis\(\) method/,
+      () => {return lokiSource('http://localhost:3100', '{app="test"}', 10, collector, null)},
+      /Clock must have a millis\(\) method/u,
       'Should reject missing clock'
     );
   });