odac 1.4.7 → 1.4.8

package/test/Database/WriteBuffer/update.test.js

@@ -0,0 +1,178 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests WriteBuffer.update() — last-write-wins coalescing.
+ * Why: Validates that repeated updates to the same row collapse into one UPDATE query,
+ * and that different rows/tables are isolated correctly.
+ */
+
+let knexLib, db, WriteBuffer
+
+beforeEach(async () => {
+  jest.resetModules()
+
+  knexLib = require('knex')
+  db = knexLib({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+
+  await db.schema.createTable('posts', table => {
+    table.integer('id').primary()
+    table.integer('views').defaultTo(0)
+    table.string('title', 255)
+    table.string('slug', 255)
+  })
+
+  await db('posts').insert([
+    {id: 1, views: 100, title: 'First Post', slug: 'first-post'},
+    {id: 2, views: 200, title: 'Second Post', slug: 'second-post'}
+  ])
+
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  const Ipc = require('../../../src/Ipc')
+  global.Odac = {
+    Config: {buffer: {flushInterval: 999999, checkpointInterval: 999999}},
+    Storage: {
+      isReady: () => false,
+      put: jest.fn(),
+      remove: jest.fn(),
+      getRange: () => []
+    },
+    Ipc
+  }
+  await Ipc.init()
+
+  WriteBuffer = require('../../../src/Database/WriteBuffer')
+  await WriteBuffer.init({default: db})
+})
+
+afterEach(async () => {
+  await WriteBuffer.close()
+  await Odac.Ipc.close()
+  await db.destroy()
+  delete global.Odac
+})
+
+describe('WriteBuffer - update()', () => {
+  it('should buffer and flush a single update', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Updated Title'})
+    await WriteBuffer.flush()
+
+    const row = await db('posts').where({id: 1}).first()
+    expect(row.title).toBe('Updated Title')
+    expect(row.slug).toBe('first-post') // Untouched
+  })
+
+  it('should merge multiple updates (last-write-wins)', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'First Update'})
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Second Update'})
+    await WriteBuffer.flush()
+
+    const row = await db('posts').where({id: 1}).first()
+    expect(row.title).toBe('Second Update')
+  })
+
+  it('should merge different columns from multiple updates', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'New Title'})
+    await WriteBuffer.update('default', 'posts', 1, {slug: 'new-slug'})
+    await WriteBuffer.flush()
+
+    const row = await db('posts').where({id: 1}).first()
+    expect(row.title).toBe('New Title')
+    expect(row.slug).toBe('new-slug')
+  })
+
+  it('should handle different rows independently', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Row 1'})
+    await WriteBuffer.update('default', 'posts', 2, {title: 'Row 2'})
+    await WriteBuffer.flush()
+
+    const row1 = await db('posts').where({id: 1}).first()
+    const row2 = await db('posts').where({id: 2}).first()
+    expect(row1.title).toBe('Row 1')
+    expect(row2.title).toBe('Row 2')
+  })
+
+  it('should handle composite where key', async () => {
+    await db.schema.createTable('user_prefs', table => {
+      table.string('pref_key', 50)
+      table.integer('user_id')
+      table.string('value', 255)
+      table.primary(['pref_key', 'user_id'])
+    })
+    await db('user_prefs').insert({pref_key: 'theme', user_id: 1, value: 'light'})
+
+    await WriteBuffer.update('default', 'user_prefs', {pref_key: 'theme', user_id: 1}, {value: 'dark'})
+    await WriteBuffer.flush()
+
+    const row = await db('user_prefs').where({pref_key: 'theme', user_id: 1}).first()
+    expect(row.value).toBe('dark')
+  })
+
+  it('should return true when buffered', async () => {
+    const result = await WriteBuffer.update('default', 'posts', 1, {title: 'Test'})
+    expect(result).toBe(true)
+  })
+
+  it('should clear update index after successful flush', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Test'})
+    await WriteBuffer.flush()
+
+    const remaining = await Odac.Ipc.smembers('wb:idx:updates')
+    expect(remaining).toHaveLength(0)
+  })
+
+  it('should combine increment and update on same row during flush', async () => {
+    await WriteBuffer.increment('default', 'posts', 1, 'views', 5)
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Combo Test'})
+    await WriteBuffer.flush()
+
+    const row = await db('posts').where({id: 1}).first()
+    expect(row.views).toBe(105)
+    expect(row.title).toBe('Combo Test')
+  })
+
+  it('should handle different tables independently', async () => {
+    await db.schema.createTable('comments', table => {
+      table.integer('id').primary()
+      table.string('body', 255)
+    })
+    await db('comments').insert({id: 1, body: 'Original'})
+
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Post Updated'})
+    await WriteBuffer.update('default', 'comments', 1, {body: 'Comment Updated'})
+    await WriteBuffer.flush()
+
+    const post = await db('posts').where({id: 1}).first()
+    const comment = await db('comments').where({id: 1}).first()
+    expect(post.title).toBe('Post Updated')
+    expect(comment.body).toBe('Comment Updated')
+  })
+
+  it('should scope flush to specific table when provided', async () => {
+    await db.schema.createTable('comments', table => {
+      table.integer('id').primary()
+      table.string('body', 255)
+    })
+    await db('comments').insert({id: 1, body: 'Original'})
+
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Post Updated'})
+    await WriteBuffer.update('default', 'comments', 1, {body: 'Comment Updated'})
+
+    // Flush only posts
+    await WriteBuffer.flush('default', 'posts')
+
+    const post = await db('posts').where({id: 1}).first()
+    const comment = await db('comments').where({id: 1}).first()
+    expect(post.title).toBe('Post Updated')
+    expect(comment.body).toBe('Original') // Not flushed
+  })
+
+  it('should not modify DB before flush is called', async () => {
+    await WriteBuffer.update('default', 'posts', 1, {title: 'Buffered Only'})
+
+    const row = await db('posts').where({id: 1}).first()
+    expect(row.title).toBe('First Post') // Still original
+  })
+})

package/test/Ipc/hset.test.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests Ipc hash operations: hset() and hgetall().
+ * Why: Validates that hash merge semantics work correctly for Write-Behind Cache
+ * update coalescing (last-write-wins per field).
+ */
+
+let Ipc
+
+beforeEach(async () => {
+  jest.resetModules()
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  Ipc = require('../../src/Ipc')
+  global.Odac = {Config: {}}
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Ipc.close()
+  delete global.Odac
+})
+
+describe('Ipc - hset()', () => {
+  it('should store and retrieve hash fields', async () => {
+    await Ipc.hset('hash:a', {title: 'Hello', views: 100})
+    const result = await Ipc.hgetall('hash:a')
+    expect(result).toEqual({title: 'Hello', views: 100})
+  })
+
+  it('should merge new fields into existing hash', async () => {
+    await Ipc.hset('hash:b', {title: 'First'})
+    await Ipc.hset('hash:b', {slug: 'first-post'})
+    const result = await Ipc.hgetall('hash:b')
+    expect(result).toEqual({title: 'First', slug: 'first-post'})
+  })
+
+  it('should overwrite existing fields (last-write-wins)', async () => {
+    await Ipc.hset('hash:c', {title: 'Old'})
+    await Ipc.hset('hash:c', {title: 'New'})
+    const result = await Ipc.hgetall('hash:c')
+    expect(result).toEqual({title: 'New'})
+  })
+
+  it('should return null for non-existent hash', async () => {
+    const result = await Ipc.hgetall('hash:nonexistent')
+    expect(result).toBeNull()
+  })
+
+  it('should be deletable via del()', async () => {
+    await Ipc.hset('hash:d', {title: 'Test'})
+    await Ipc.del('hash:d')
+    const result = await Ipc.hgetall('hash:d')
+    expect(result).toBeNull()
+  })
+})

package/test/Ipc/incrBy.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests Ipc.incrBy() atomic counter operation.
+ * Why: Validates that concurrent increment operations are atomic and return
+ * accurate accumulated values, essential for Write-Behind Cache counters.
+ */
+
+let Ipc
+
+beforeEach(async () => {
+  jest.resetModules()
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  Ipc = require('../../src/Ipc')
+  global.Odac = {Config: {}}
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Ipc.close()
+  delete global.Odac
+})
+
+describe('Ipc - incrBy()', () => {
+  it('should initialize and return delta on first call', async () => {
+    const result = await Ipc.incrBy('counter:a', 5)
+    expect(result).toBe(5)
+  })
+
+  it('should accumulate multiple increments', async () => {
+    await Ipc.incrBy('counter:b', 3)
+    await Ipc.incrBy('counter:b', 7)
+    const result = await Ipc.incrBy('counter:b', 2)
+    expect(result).toBe(12) // 3 + 7 + 2
+  })
+
+  it('should handle negative deltas (decrement)', async () => {
+    await Ipc.incrBy('counter:c', 10)
+    const result = await Ipc.incrBy('counter:c', -3)
+    expect(result).toBe(7)
+  })
+
+  it('should not interfere with different keys', async () => {
+    await Ipc.incrBy('counter:x', 5)
+    await Ipc.incrBy('counter:y', 10)
+
+    expect(await Ipc.get('counter:x')).toBe(5)
+    expect(await Ipc.get('counter:y')).toBe(10)
+  })
+
+  it('should be readable via get()', async () => {
+    await Ipc.incrBy('counter:d', 42)
+    const result = await Ipc.get('counter:d')
+    expect(result).toBe(42)
+  })
+
+  it('should work with decrBy()', async () => {
+    await Ipc.incrBy('counter:e', 10)
+    const result = await Ipc.decrBy('counter:e', 4)
+    expect(result).toBe(6)
+  })
+})

package/test/Ipc/lock.test.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests Ipc distributed lock: lock() and unlock().
+ * Why: Validates that only one process can hold the flush lock at a time,
+ * preventing duplicate writes in horizontal scaling scenarios.
+ */
+
+let Ipc
+
+beforeEach(async () => {
+  jest.resetModules()
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  Ipc = require('../../src/Ipc')
+  global.Odac = {Config: {}}
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Ipc.close()
+  delete global.Odac
+})
+
+describe('Ipc - lock()', () => {
+  it('should acquire lock and return true', async () => {
+    const result = await Ipc.lock('lock:a', 5)
+    expect(result).toBe(true)
+  })
+
+  it('should reject second acquisition (mutex)', async () => {
+    await Ipc.lock('lock:b', 5)
+    const result = await Ipc.lock('lock:b', 5)
+    expect(result).toBe(false)
+  })
+
+  it('should allow re-acquisition after unlock', async () => {
+    await Ipc.lock('lock:c', 5)
+    await Ipc.unlock('lock:c')
+    const result = await Ipc.lock('lock:c', 5)
+    expect(result).toBe(true)
+  })
+
+  it('should auto-expire after TTL', async () => {
+    await Ipc.lock('lock:d', 1) // 1 second TTL
+
+    // Wait for expiry
+    await new Promise(r => setTimeout(r, 1100))
+
+    // Lock should be available again
+    const result = await Ipc.lock('lock:d', 5)
+    expect(result).toBe(true)
+  })
+
+  it('should not interfere with different lock keys', async () => {
+    await Ipc.lock('lock:e', 5)
+    const result = await Ipc.lock('lock:f', 5)
+    expect(result).toBe(true)
+  })
+})

package/test/Ipc/rpush.test.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests Ipc list operations: rpush() and lrange().
+ * Why: Validates that batch insert queue (Write-Behind Cache) correctly appends
+ * items and retrieves them in order.
+ */
+
+let Ipc
+
+beforeEach(async () => {
+  jest.resetModules()
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  Ipc = require('../../src/Ipc')
+  global.Odac = {Config: {}}
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Ipc.close()
+  delete global.Odac
+})
+
+describe('Ipc - rpush()', () => {
+  it('should append items and return new length', async () => {
+    const len1 = await Ipc.rpush('list:a', {action: 'view'})
+    const len2 = await Ipc.rpush('list:a', {action: 'click'})
+    expect(len1).toBe(1)
+    expect(len2).toBe(2)
+  })
+
+  it('should append multiple items at once', async () => {
+    const len = await Ipc.rpush('list:b', {a: 1}, {a: 2}, {a: 3})
+    expect(len).toBe(3)
+  })
+})
+
+describe('Ipc - lrange()', () => {
+  it('should return all items with 0, -1', async () => {
+    await Ipc.rpush('list:c', 'first')
+    await Ipc.rpush('list:c', 'second')
+    await Ipc.rpush('list:c', 'third')
+
+    const result = await Ipc.lrange('list:c', 0, -1)
+    expect(result).toEqual(['first', 'second', 'third'])
+  })
+
+  it('should return a range of items', async () => {
+    await Ipc.rpush('list:d', 'a', 'b', 'c', 'd')
+    const result = await Ipc.lrange('list:d', 1, 2)
+    expect(result).toEqual(['b', 'c'])
+  })
+
+  it('should return empty array for non-existent list', async () => {
+    const result = await Ipc.lrange('list:nonexistent', 0, -1)
+    expect(result).toEqual([])
+  })
+
+  it('should clear list on del()', async () => {
+    await Ipc.rpush('list:e', 'item')
+    await Ipc.del('list:e')
+    const result = await Ipc.lrange('list:e', 0, -1)
+    expect(result).toEqual([])
+  })
+})

package/test/Ipc/sadd.test.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests Ipc set operations: sadd(), smembers(), srem().
+ * Why: WriteBuffer uses index sets to track active counter/update/queue keys
+ * for efficient flush discovery without expensive SCAN operations.
+ */
+
+let Ipc
+
+beforeEach(async () => {
+  jest.resetModules()
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  Ipc = require('../../src/Ipc')
+  global.Odac = {Config: {}}
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Ipc.close()
+  delete global.Odac
+})
+
+describe('Ipc - sadd()', () => {
+  it('should add members and return count of new additions', async () => {
+    const added = await Ipc.sadd('set:a', 'x', 'y', 'z')
+    expect(added).toBe(3)
+  })
+
+  it('should not duplicate existing members', async () => {
+    await Ipc.sadd('set:b', 'x', 'y')
+    const added = await Ipc.sadd('set:b', 'y', 'z')
+    expect(added).toBe(1) // Only 'z' is new
+  })
+})
+
+describe('Ipc - smembers()', () => {
+  it('should return all members', async () => {
+    await Ipc.sadd('set:c', 'a', 'b', 'c')
+    const members = await Ipc.smembers('set:c')
+    expect(members.sort()).toEqual(['a', 'b', 'c'])
+  })
+
+  it('should return empty array for non-existent set', async () => {
+    const result = await Ipc.smembers('set:nonexistent')
+    expect(result).toEqual([])
+  })
+})
+
+describe('Ipc - srem()', () => {
+  it('should remove specified members', async () => {
+    await Ipc.sadd('set:d', 'a', 'b', 'c')
+    const removed = await Ipc.srem('set:d', 'b')
+    expect(removed).toBe(1)
+
+    const remaining = await Ipc.smembers('set:d')
+    expect(remaining.sort()).toEqual(['a', 'c'])
+  })
+
+  it('should return 0 for non-existent members', async () => {
+    await Ipc.sadd('set:e', 'x')
+    const removed = await Ipc.srem('set:e', 'nonexistent')
+    expect(removed).toBe(0)
+  })
+})