jexidb 2.1.0 → 2.1.2

package/test/writebuffer-flush-resilience.test.js

@@ -1,204 +0,0 @@
-const { Database } = require('../src/Database.mjs')
-const fs = require('fs')
-const path = require('path')
-
-describe('WriteBuffer Flush Resilience', () => {
-  let testDir
-  let db
-
-  beforeEach(async () => {
-    testDir = path.join(__dirname, 'test-files', 'writebuffer-resilience')
-    if (fs.existsSync(testDir)) {
-      fs.rmSync(testDir, { recursive: true, force: true })
-    }
-    fs.mkdirSync(testDir, { recursive: true })
-
-    db = new Database(path.join(testDir, 'test'), {
-      indexes: { name: 'string', tags: 'array:string' },
-      debugMode: false, // Disable debug mode to reduce noise
-    })
-    await db.init()
-  })
-
-  afterEach(async () => {
-    if (db && !db.destroyed) {
-      await db.close()
-    }
-    // Retry mechanism for cleanup
-    let retries = 3
-    while (retries > 0) {
-      try {
-        if (fs.existsSync(testDir)) {
-          fs.rmSync(testDir, { recursive: true, force: true })
-        }
-        break
-      } catch (error) {
-        retries--
-        if (retries === 0) throw error
-        await new Promise(resolve => setTimeout(resolve, 100))
-      }
-    }
-  })
-
-  it('should handle concurrent operations that add to writeBuffer during flush', async () => {
-    // First, create the database file with some initial data
-    await db.insert({ name: 'initial', tags: ['initial'] })
-    // Don't flush the initial record - keep it in writeBuffer for the test
-
-    // Simulate concurrent operations that can add items to writeBuffer
-    const operations = []
-    
-    // Start multiple concurrent operations
-    for (let i = 0; i < 10; i++) {
-      operations.push(
-        db.insert({ name: `item${i}`, tags: [`tag${i}`, `category${i % 3}`] }).then(() => {
-          console.log(`✅ Inserted item${i}`)
-        })
-      )
-    }
-
-    // Add more operations
-    for (let i = 10; i < 15; i++) {
-      operations.push(
-        db.insert({ name: `item${i}`, tags: [`tag${i}`, `category${i % 3}`] }).then(() => {
-          console.log(`✅ Inserted item${i}`)
-        })
-      )
-    }
-
-    // Wait for all insert operations to complete first
-    await Promise.all(operations)
-    
-    // Then flush to save all data
-    await db.flush()
-
-    // Verify all data was saved correctly (15 new items + 1 initial = 16 total)
-    const allItems = await db.find({})
-    expect(allItems).toHaveLength(16)
-    
-    // Verify no data was lost
-    for (let i = 0; i < 15; i++) {
-      const item = await db.findOne({ name: `item${i}` })
-      expect(item).toBeTruthy()
-      expect(item.name).toBe(`item${i}`)
-      expect(item.tags).toContain(`tag${i}`)
-    }
-  })
-
-  it('should handle update operations that add indexOffset to writeBuffer during flush', async () => {
-    // Insert initial data and ensure it's saved to create the file
-    await db.insert({ name: 'item1', tags: ['tag1', 'tag2'] })
-    await db.insert({ name: 'item2', tags: ['tag2', 'tag3'] })
-    await db.insert({ name: 'item3', tags: ['tag1', 'tag3'] })
-    
-    // Ensure initial data is saved to create the database file
-    await db.flush() // Use flush() to actually write data to file
-
-    // Verify all records exist before update
-    const beforeUpdate1 = await db.findOne({ name: 'item1' })
-    const beforeUpdate2 = await db.findOne({ name: 'item2' })
-    const beforeUpdate3 = await db.findOne({ name: 'item3' })
-    expect(beforeUpdate1).toBeTruthy()
-    expect(beforeUpdate2).toBeTruthy()
-    expect(beforeUpdate3).toBeTruthy()
-
-    // Use sequential operations to avoid Windows file locking conflicts
-    // Add update operations sequentially to avoid deadlocks
-    await db.update({ name: 'item1' }, { name: 'item1', tags: ['tag1', 'tag2', 'tag4'] })
-    await db.update({ name: 'item2' }, { name: 'item2', tags: ['tag2', 'tag3', 'tag5'] })
-    await db.update({ name: 'item3' }, { name: 'item3', tags: ['tag1', 'tag3', 'tag6'] })
-    
-    // Then flush to save the updates
-    await db.flush()
-
-    // Verify updates were applied correctly
-    const updated1 = await db.findOne({ name: 'item1' })
-    expect(updated1).toBeTruthy()
-    expect(updated1.tags).toContain('tag4')
-    
-    const updated2 = await db.findOne({ name: 'item2' })
-    expect(updated2).toBeTruthy()
-    expect(updated2.tags).toContain('tag5')
-    
-    const updated3 = await db.findOne({ name: 'item3' })
-    expect(updated3).toBeTruthy()
-    expect(updated3.tags).toContain('tag6')
-  }, 30000) // 30 second timeout
-
-  it('should handle delete operations that add indexOffset to writeBuffer during flush', async () => {
-    // Insert initial data and ensure it's saved to create the file
-    await db.insert({ name: 'item1', tags: ['tag1', 'tag2'] })
-    await db.insert({ name: 'item2', tags: ['tag2', 'tag3'] })
-    await db.insert({ name: 'item3', tags: ['tag1', 'tag3'] })
-    await db.insert({ name: 'item4', tags: ['tag4', 'tag5'] })
-    
-    // Ensure initial data is saved to create the database file
-    await db.flush() // Use flush() to actually write data to file
-
-    // Use sequential operations to avoid Windows file locking conflicts
-    // Add delete operations sequentially to avoid deadlocks
-    await db.delete({ name: 'item1' })
-    await db.delete({ name: 'item2' })
-    
-    // Then flush to save the deletions
-    await db.flush()
-
-    // Verify deletions were applied correctly
-    const remaining = await db.find({})
-    expect(remaining).toHaveLength(2)
-    
-    const item3 = await db.findOne({ name: 'item3' })
-    expect(item3).toBeTruthy()
-    
-    const item4 = await db.findOne({ name: 'item4' })
-    expect(item4).toBeTruthy()
-  }, 30000) // 30 second timeout
-
-  it('should continue flushing until writeBuffer is completely empty', async () => {
-    // This test simulates the exact scenario that was causing the error
-    const operations = []
-    
-    // Start multiple operations that will add to writeBuffer
-    for (let i = 0; i < 25; i++) {
-      operations.push(
-        db.insert({ name: `item${i}`, tags: [`tag${i}`] })
-      )
-    }
-
-    // Wait for all insert operations to complete first
-    await Promise.all(operations)
-    
-    // Then save to persist all data
-    await db.save()
-
-    // Verify all data was saved
-    const allItems = await db.find({})
-    expect(allItems).toHaveLength(25)
-  })
-
-  it('should handle writeBuffer flush resilience without errors', async () => {
-    // This test verifies that the writeBuffer flush resilience works without throwing errors
-    const operations = []
-    
-    // Add operations first
-    for (let i = 0; i < 5; i++) {
-      operations.push(
-        db.insert({ name: `item${i}`, tags: [`tag${i}`] })
-      )
-    }
-
-    // Wait for all insert operations to complete first
-    await Promise.all(operations)
-    
-    // Then save to persist all data
-    await db.save()
-
-    // Verify data was saved correctly (be more tolerant of Windows file locking issues)
-    const allItems = await db.find({})
-    expect(allItems.length).toBeGreaterThan(0) // At least some data should be saved
-    expect(allItems.length).toBeLessThanOrEqual(5) // But not more than expected
-    
-    // Verify the flush resilience mechanism worked (no "WriteBuffer not empty" errors)
-    // The test passes if we get here without throwing errors
-  }, 15000)
-})