feishu-user-plugin 1.3.8 → 1.3.9

package/src/test-events-cursor.js

@@ -0,0 +1,56 @@
+// src/test-events-cursor.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { ensureLog, appendEvent } = require('./events/event-log');
+const { drain, readSnapshot, resetCursorTo } = require('./events/cursor');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-cur-'));
+  const logPath = path.join(dir, 'events.jsonl');
+  ensureLog(logPath);
+
+  // No events → empty drain.
+  let r = drain(dir);
+  assert.equal(r.events.length, 0);
+
+  // Append 3 events, drain reads them.
+  appendEvent(logPath, { event_id: 'a', ts: 1, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'b', ts: 2, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'c', ts: 3, profile: 'default', payload: {} });
+
+  r = drain(dir);
+  assert.equal(r.events.length, 3);
+  assert.equal(r.advanced, true);
+
+  // Second drain returns nothing (cursor advanced).
+  r = drain(dir);
+  assert.equal(r.events.length, 0);
+
+  // Peek doesn't advance.
+  appendEvent(logPath, { event_id: 'd', ts: 4, profile: 'default', payload: {} });
+  r = drain(dir, { peek: true });
+  assert.equal(r.events.length, 1);
+  assert.equal(r.advanced, false);
+  // Real drain afterward still returns the same event.
+  r = drain(dir);
+  assert.equal(r.events.length, 1);
+  assert.equal(r.events[0].event_id, 'd');
+
+  // Snapshot.
+  const snap = readSnapshot(dir);
+  assert.equal(snap.pending, 0);
+  assert.ok(snap.cursor.offset > 0);
+
+  // Reset cursor to 0 → next drain returns all 4.
+  resetCursorTo(dir, 0);
+  r = drain(dir);
+  assert.equal(r.events.length, 4);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('cursor.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-lockfile.js

@@ -0,0 +1,36 @@
+// src/test-events-lockfile.js (new file; require it from src/test-all.js)
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { acquireLongLived, withMutex } = require('./events/lockfile');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-lock-'));
+  const lockPath = path.join(dir, 'test.lock');
+
+  // Long-lived: first acquire works, second returns null.
+  const handle1 = acquireLongLived(lockPath, { info: { test: 1 } });
+  assert.ok(handle1, 'first acquire should succeed');
+  const handle2 = acquireLongLived(lockPath, { info: { test: 2 } });
+  assert.equal(handle2, null, 'second acquire should fail (lock held)');
+  handle1.release();
+
+  // After release, can acquire again.
+  const handle3 = acquireLongLived(lockPath, { info: { test: 3 } });
+  assert.ok(handle3, 'third acquire after release should succeed');
+  handle3.release();
+
+  // withMutex serializes.
+  const mutexPath = path.join(dir, 'mutex.lock');
+  let counter = 0;
+  withMutex(mutexPath, () => { counter += 1; });
+  withMutex(mutexPath, () => { counter += 1; });
+  assert.equal(counter, 2);
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('lockfile.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-log.js

@@ -0,0 +1,67 @@
+// src/test-events-log.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { ensureLog, appendEvent, readFrom, repairTail, maybeRotate, forceRotate } = require('./events/event-log');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-log-'));
+  const logPath = path.join(dir, 'events.jsonl');
+
+  // Append + read
+  ensureLog(logPath);
+  appendEvent(logPath, { event_id: 'a', ts: 1, profile: 'default', payload: {} });
+  appendEvent(logPath, { event_id: 'b', ts: 2, profile: 'default', payload: {} });
+
+  let r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 2);
+  assert.equal(r.events[0].event_id, 'a');
+  assert.equal(r.events[1].event_id, 'b');
+
+  // Read with offset
+  r = readFrom(logPath, r.events.length === 2 ? r.nextOffset : 0);
+  assert.equal(r.events.length, 0);
+
+  // Partial-line tolerance: append broken line
+  fs.appendFileSync(logPath, '{"event_id":"c","ts":3,"profile":"default","payload":{}}');
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 2, 'partial last line should not be consumed');
+
+  // Repair tail
+  const beforeSize = fs.statSync(logPath).size;
+  const repair = repairTail(logPath);
+  assert.equal(repair.repaired, true, 'repair should run');
+  assert.ok(repair.sizeAfter < beforeSize, 'truncation occurred');
+
+  // After repair, can append normally
+  appendEvent(logPath, { event_id: 'd', ts: 4, profile: 'default', payload: {} });
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 3, 'after repair + append, 3 full events');
+  assert.equal(r.events[2].event_id, 'd');
+
+  // Defer-rotate: size below threshold → no rotation
+  let rot = maybeRotate(logPath, r.nextOffset, 1024 * 1024);
+  assert.equal(rot.rotated, false);
+
+  // Defer-rotate: size above threshold + cursor caught up → rotation
+  // (we'll use a tiny threshold)
+  rot = maybeRotate(logPath, r.nextOffset, 1);
+  assert.equal(rot.rotated, true);
+  assert.ok(fs.existsSync(rot.droppedPath));
+  assert.equal(fs.statSync(logPath).size, 0, 'new log empty after rotate');
+
+  // Force rotate: even with cursor 0 (behind), drops + writes _rotated event
+  appendEvent(logPath, { event_id: 'e', ts: 5, profile: 'default', payload: {} });
+  forceRotate(logPath, fs.statSync(logPath).size);
+  r = readFrom(logPath, 0);
+  assert.equal(r.events.length, 1);
+  assert.equal(r.events[0].event_id, '_rotated');
+  assert.equal(r.events[0].profile, '_system');
+
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('event-log.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };

package/src/test-events-owner.js

@@ -0,0 +1,64 @@
+// src/test-events-owner.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('node:assert/strict');
+const { tryClaim, readOwnerInfo, STALE_MS } = require('./events/owner');
+
+function run() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fish-own-'));
+
+  // Initial claim succeeds.
+  const h1 = tryClaim(dir, { info: { wsProfile: 'default' } });
+  assert.equal(h1.isOwner, true);
+
+  // Second claim fails (lock held).
+  const h2 = tryClaim(dir);
+  assert.equal(h2.isOwner, false);
+  assert.equal(h2.ownerInfo.pid, process.pid);
+
+  // readOwnerInfo reflects state.
+  const info = readOwnerInfo(dir);
+  assert.equal(info.exists, true);
+  assert.equal(info.alive, true);
+  assert.equal(info.pid, process.pid);
+
+  // Heartbeat updates mtime.
+  const beforeMtime = info.mtimeMs;
+  // Force a slight delay then heartbeat
+  const target = Date.now();
+  while (Date.now() - target < 50) {} // small busy wait
+  const ok = h1.heartbeat();
+  assert.equal(ok, true);
+  const afterMtime = readOwnerInfo(dir).mtimeMs;
+  assert.ok(afterMtime >= beforeMtime);
+
+  h1.release();
+
+  // After release, readOwnerInfo says no owner.
+  const info2 = readOwnerInfo(dir);
+  assert.equal(info2.exists, false);
+
+  // After release, can re-claim.
+  const h3 = tryClaim(dir);
+  assert.equal(h3.isOwner, true);
+  h3.release();
+
+  // Force claim over an existing lock.
+  const h4 = tryClaim(dir, { info: { wsProfile: 'A' } });
+  const h5 = tryClaim(dir, { info: { wsProfile: 'B' }, force: true });
+  assert.equal(h5.isOwner, true);
+  // h4's heartbeat should now fail because its lock file got stolen.
+  // (Best-effort — heartbeat returns false if file isn't there to utimes.)
+  // We don't assert this strictly because the file's still around (we renamed
+  // it, didn't delete). Instead just verify h5 holds the new lock.
+  const info3 = readOwnerInfo(dir);
+  assert.equal(info3.exists, true);
+
+  h5.release();
+  fs.rmSync(dir, { recursive: true, force: true });
+  console.log('owner.js: PASS');
+}
+
+if (require.main === module) run();
+module.exports = { run };