resplite 1.0.0 → 1.0.4

package/test/integration/blocking.test.js

@@ -0,0 +1,107 @@
+/**
+ * Integration tests for blocking list commands (BLPOP, BRPOP) — SPEC_E.
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+describe('Blocking lists (BLPOP/BRPOP)', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('BLPOP returns immediately when key has element', async () => {
+    await sendCommand(port, argv('RPUSH', 'bq1', 'a'));
+    const reply = await sendCommand(port, argv('BLPOP', 'bq1', '1'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    assert.equal(parsed.value.length, 2);
+    assert.equal(parsed.value[0].toString('utf8'), 'bq1');
+    assert.equal(parsed.value[1].toString('utf8'), 'a');
+  });
+
+  it('BRPOP returns immediately when key has element', async () => {
+    await sendCommand(port, argv('RPUSH', 'bq2', 'x'));
+    const reply = await sendCommand(port, argv('BRPOP', 'bq2', '1'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    assert.equal(parsed.value[0].toString('utf8'), 'bq2');
+    assert.equal(parsed.value[1].toString('utf8'), 'x');
+  });
+
+  it('BLPOP blocks then returns after RPUSH from another client', async () => {
+    const blockPromise = sendCommand(port, argv('BLPOP', 'bq3', '5'));
+    await delay(80);
+    await sendCommand(port, argv('RPUSH', 'bq3', 'woken'));
+    const reply = await blockPromise;
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    assert.equal(parsed.value[0].toString('utf8'), 'bq3');
+    assert.equal(parsed.value[1].toString('utf8'), 'woken');
+  });
+
+  it('BRPOP blocks then returns after LPUSH from another client', async () => {
+    const blockPromise = sendCommand(port, argv('BRPOP', 'bq4', '5'));
+    await delay(80);
+    await sendCommand(port, argv('LPUSH', 'bq4', 'tail'));
+    const reply = await blockPromise;
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    assert.equal(parsed.value[0].toString('utf8'), 'bq4');
+    assert.equal(parsed.value[1].toString('utf8'), 'tail');
+  });
+
+  it('BLPOP with timeout returns nil after timeout', async () => {
+    const reply = await sendCommand(port, argv('BLPOP', 'emptyq', '1'));
+    const parsed = tryParseValue(reply, 0);
+    assert.strictEqual(parsed.value, null);
+  });
+
+  it('BLPOP wrong number of arguments returns error', async () => {
+    const reply = await sendCommand(port, argv('BLPOP', 'k'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(parsed.value && parsed.value.error);
+    assert.ok(parsed.value.error.includes('wrong number of arguments'));
+  });
+
+  it('BLPOP invalid timeout returns error', async () => {
+    const reply = await sendCommand(port, argv('BLPOP', 'k', 'x'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(parsed.value && parsed.value.error);
+    assert.ok(parsed.value.error.includes('timeout'));
+  });
+
+  it('BLPOP on wrong type key returns WRONGTYPE', async () => {
+    await sendCommand(port, argv('SET', 'strkey', 'v'));
+    const reply = await sendCommand(port, argv('BLPOP', 'strkey', '0'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(parsed.value && parsed.value.error);
+    assert.ok(parsed.value.error.includes('WRONGTYPE'));
+  });
+
+  it('BLPOP multi-key returns first available in key order', async () => {
+    const blockPromise = sendCommand(port, argv('BLPOP', 'k1', 'k2', '5'));
+    await delay(50);
+    await sendCommand(port, argv('RPUSH', 'k2', 'second'));
+    const reply = await blockPromise;
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    assert.equal(parsed.value[0].toString('utf8'), 'k2');
+    assert.equal(parsed.value[1].toString('utf8'), 'second');
+  });
+});

package/test/unit/migration-registry.test.js

@@ -0,0 +1,127 @@
+/**
+ * Unit tests for migration registry (SPEC_F §F.5).
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { openDb } from '../../src/storage/sqlite/db.js';
+import {
+  createRun,
+  getRun,
+  setRunStatus,
+  updateBulkProgress,
+  upsertDirtyKey,
+  getDirtyBatch,
+  markDirtyState,
+  getDirtyCounts,
+  logError,
+  RUN_STATUS,
+} from '../../src/migration/registry.js';
+import { tmpDbPath } from '../helpers/tmp.js';
+
+describe('migration registry', () => {
+  it('createRun inserts a new run and is idempotent', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    const { run_id, created } = createRun(db, 'run_1', 'redis://localhost:6379', { scan_count_hint: 500 });
+    assert.equal(run_id, 'run_1');
+    assert.equal(created, true);
+
+    const { created: created2 } = createRun(db, 'run_1', 'redis://localhost:6379');
+    assert.equal(created2, false);
+  });
+
+  it('getRun returns run row', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_2', 'redis://x:6379');
+    const run = getRun(db, 'run_2');
+    assert.ok(run);
+    assert.equal(run.run_id, 'run_2');
+    assert.equal(run.source_uri, 'redis://x:6379');
+    assert.equal(run.status, RUN_STATUS.RUNNING);
+    assert.equal(run.scan_cursor, '0');
+  });
+
+  it('setRunStatus and updateBulkProgress update run', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_3', 'redis://x:6379');
+    setRunStatus(db, 'run_3', RUN_STATUS.PAUSED);
+    assert.equal(getRun(db, 'run_3').status, RUN_STATUS.PAUSED);
+
+    updateBulkProgress(db, 'run_3', {
+      scan_cursor: '42',
+      scanned_keys: 100,
+      migrated_keys: 98,
+      skipped_keys: 1,
+      error_keys: 1,
+      migrated_bytes: 5000,
+    });
+    const run = getRun(db, 'run_3');
+    assert.equal(run.scan_cursor, '42');
+    assert.equal(run.scanned_keys, 100);
+    assert.equal(run.migrated_keys, 98);
+    assert.equal(run.migrated_bytes, 5000);
+  });
+
+  it('upsertDirtyKey inserts and updates', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_4', 'redis://x:6379');
+    const key = Buffer.from('mykey', 'utf8');
+
+    upsertDirtyKey(db, 'run_4', key, 'set');
+    let batch = getDirtyBatch(db, 'run_4', 'dirty', 10);
+    assert.equal(batch.length, 1);
+    assert.equal(batch[0].key.toString('utf8'), 'mykey');
+
+    upsertDirtyKey(db, 'run_4', 'mykey', 'hset');
+    batch = getDirtyBatch(db, 'run_4', 'dirty', 10);
+    assert.equal(batch.length, 1);
+    const counts = getDirtyCounts(db, 'run_4');
+    assert.ok(counts.dirty >= 1);
+  });
+
+  it('upsertDirtyKey marks deleted then dirty again', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_5', 'redis://x:6379');
+    upsertDirtyKey(db, 'run_5', 'key1', 'del');
+    let batch = getDirtyBatch(db, 'run_5', 'deleted', 10);
+    assert.equal(batch.length, 1);
+    assert.equal(batch[0].key.toString('utf8'), 'key1');
+    const row = db.prepare('SELECT state FROM migration_dirty_keys WHERE run_id = ? AND key = ?').get('run_5', Buffer.from('key1', 'utf8'));
+    assert.equal(row.state, 'deleted');
+
+    upsertDirtyKey(db, 'run_5', 'key1', 'set');
+    const row2 = db.prepare('SELECT state FROM migration_dirty_keys WHERE run_id = ? AND key = ?').get('run_5', Buffer.from('key1', 'utf8'));
+    assert.equal(row2.state, 'dirty');
+  });
+
+  it('getDirtyBatch returns keys in state order', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_6', 'redis://x:6379');
+    upsertDirtyKey(db, 'run_6', 'a', 'set');
+    upsertDirtyKey(db, 'run_6', 'b', 'set');
+    const batch = getDirtyBatch(db, 'run_6', 'dirty', 1);
+    assert.equal(batch.length, 1);
+    assert.ok(['a', 'b'].includes(batch[0].key.toString('utf8')));
+  });
+
+  it('markDirtyState updates state and run counters', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_7', 'redis://x:6379');
+    upsertDirtyKey(db, 'run_7', 'k1', 'set');
+    markDirtyState(db, 'run_7', 'k1', 'applied');
+    assert.equal(getRun(db, 'run_7').dirty_keys_applied, 1);
+    upsertDirtyKey(db, 'run_7', 'k2', 'set');
+    markDirtyState(db, 'run_7', 'k2', 'deleted');
+    assert.equal(getRun(db, 'run_7').dirty_keys_deleted, 1);
+  });
+
+  it('logError inserts into migration_errors', () => {
+    const db = openDb(tmpDbPath(), { pragmaTemplate: 'minimal' });
+    createRun(db, 'run_8', 'redis://x:6379');
+    logError(db, 'run_8', 'bulk', 'test error', Buffer.from('key', 'utf8'));
+    const row = db.prepare('SELECT * FROM migration_errors WHERE run_id = ?').get('run_8');
+    assert.ok(row);
+    assert.equal(row.stage, 'bulk');
+    assert.equal(row.message, 'test error');
+  });
+});