before functional changes by codex

test/integration/tick-loop.integration.test.js

@@ -0,0 +1,89 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub } = require('../helpers/factories');
+
+test('_tick emits source effluent on process output', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+
+  inst.node = node;
+  inst.source = {
+    get getEffluent() {
+      return { topic: 'Fluent', payload: { inlet: 0, F: 1, C: [] }, timestamp: 1 };
+    },
+  };
+
+  inst._tick();
+
+  assert.equal(node._sent.length, 1);
+  assert.equal(node._sent[0][0].topic, 'Fluent');
+  assert.equal(node._sent[0][1], null);
+  assert.equal(node._sent[0][2], null);
+});
+
+test('_startTickLoop schedules periodic tick after startup delay', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const delays = [];
+  const intervals = [];
+  let tickCount = 0;
+
+  inst._tick = () => {
+    tickCount += 1;
+  };
+
+  const originalSetTimeout = global.setTimeout;
+  const originalSetInterval = global.setInterval;
+
+  global.setTimeout = (fn, ms) => {
+    delays.push(ms);
+    fn();
+    return 10;
+  };
+
+  global.setInterval = (fn, ms) => {
+    intervals.push(ms);
+    fn();
+    return 22;
+  };
+
+  try {
+    inst._startTickLoop();
+  } finally {
+    global.setTimeout = originalSetTimeout;
+    global.setInterval = originalSetInterval;
+  }
+
+  assert.deepEqual(delays, [1000]);
+  assert.deepEqual(intervals, [1000]);
+  assert.equal(inst._tickInterval, 22);
+  assert.equal(tickCount, 1);
+});
+
+test('_attachCloseHandler clears tick interval and calls done callback', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+  inst.node = node;
+  inst._tickInterval = 55;
+
+  const cleared = [];
+  const originalClearInterval = global.clearInterval;
+  global.clearInterval = (id) => {
+    cleared.push(id);
+  };
+
+  let doneCalled = 0;
+
+  try {
+    inst._attachCloseHandler();
+    node._handlers.close(() => {
+      doneCalled += 1;
+    });
+  } finally {
+    global.clearInterval = originalClearInterval;
+  }
+
+  assert.deepEqual(cleared, [55]);
+  assert.equal(doneCalled, 1);
+});