119 lines
4.2 KiB
TypeScript
119 lines
4.2 KiB
TypeScript
/**
|
|
* Integration tests for clear() — fully clears storage, including across a restart.
|
|
*
|
|
* Rewritten for 8.0: the original v5.10.4 suite asserted copy-on-write internals
|
|
* (`_cow/` directory + a `cow-disabled` marker). COW was removed in 8.0 (replaced by
|
|
* generational MVCC), so those internals no longer exist. These tests verify the
|
|
* durable BEHAVIOR that the original bug report cared about: `clear()` empties the
|
|
* store, and a fresh instance opened over the same path sees no data.
|
|
*
|
|
* NO MOCKS — real filesystem + memory storage. Every brain is closed in teardown so
|
|
* background flush / writer-lock heartbeat timers cannot bleed across tests.
|
|
*/
|
|
|
|
import { describe, it, expect, afterEach } from 'vitest'
|
|
import { Brainy } from '../../src/brainy.js'
|
|
import * as fs from 'fs'
|
|
|
|
describe('clear() fully clears storage', () => {
|
|
const testStoragePath = './test-clear-persistence-' + Date.now()
|
|
const brains: Brainy[] = []
|
|
|
|
const open = async (rootDirectory = testStoragePath): Promise<Brainy> => {
|
|
const brain = new Brainy({
|
|
requireSubtype: false,
|
|
storage: { type: 'filesystem', rootDirectory }
|
|
})
|
|
await brain.init()
|
|
brains.push(brain)
|
|
return brain
|
|
}
|
|
|
|
afterEach(async () => {
|
|
for (const b of brains.splice(0)) {
|
|
try {
|
|
await b.close()
|
|
} catch {
|
|
/* already closed */
|
|
}
|
|
}
|
|
for (const p of [testStoragePath, testStoragePath + '-multi']) {
|
|
try {
|
|
if (fs.existsSync(p)) await fs.promises.rm(p, { recursive: true, force: true })
|
|
} catch {
|
|
/* ignore cleanup errors */
|
|
}
|
|
}
|
|
})
|
|
|
|
it('fully clears persistent storage, including after a restart (the reported scenario)', async () => {
|
|
const brain1 = await open()
|
|
await brain1.add({ data: 'Test Entity', type: 'concept' })
|
|
expect((await brain1.find({ type: 'concept' })).length).toBe(1)
|
|
|
|
await brain1.clear()
|
|
expect((await brain1.find({ type: 'concept' })).length).toBe(0)
|
|
await brain1.close()
|
|
|
|
// New instance over the same path — data must NOT come back.
|
|
const brain2 = await open()
|
|
expect((await brain2.find({ type: 'concept' })).length).toBe(0)
|
|
})
|
|
|
|
it('clears both entities and relations across a restart', async () => {
|
|
const brain1 = await open()
|
|
const e1 = await brain1.add({ data: 'Entity 1', type: 'person' })
|
|
const e2 = await brain1.add({ data: 'Entity 2', type: 'concept' })
|
|
await brain1.relate({ from: e1, to: e2, type: 'relatedTo' })
|
|
expect((await brain1.find({ type: 'person' })).length).toBe(1)
|
|
expect((await brain1.related({})).length).toBe(1)
|
|
|
|
await brain1.clear()
|
|
await brain1.close()
|
|
|
|
const brain2 = await open()
|
|
expect((await brain2.find({ type: 'person' })).length).toBe(0)
|
|
expect((await brain2.find({ type: 'concept' })).length).toBe(0)
|
|
expect((await brain2.related({})).length).toBe(0)
|
|
})
|
|
|
|
it('works across multiple clear() cycles and restarts', async () => {
|
|
const p = testStoragePath + '-multi'
|
|
const brain1 = await open(p)
|
|
await brain1.add({ data: 'Entity 1', type: 'concept' })
|
|
expect((await brain1.find({ type: 'concept' })).length).toBe(1)
|
|
await brain1.clear()
|
|
await brain1.close()
|
|
|
|
const brain2 = await open(p)
|
|
expect((await brain2.find({ type: 'concept' })).length).toBe(0)
|
|
await brain2.add({ data: 'Entity 2', type: 'concept' })
|
|
expect((await brain2.find({ type: 'concept' })).length).toBe(1)
|
|
await brain2.clear()
|
|
await brain2.close()
|
|
|
|
const brain3 = await open(p)
|
|
expect((await brain3.find({ type: 'concept' })).length).toBe(0)
|
|
})
|
|
|
|
it('handles clear() on empty storage', async () => {
|
|
const brain = await open()
|
|
await expect(brain.clear()).resolves.not.toThrow()
|
|
expect((await brain.find({ type: 'concept' })).length).toBe(0)
|
|
})
|
|
})
|
|
|
|
describe('clear() works for memory storage', () => {
|
|
it('clears memory storage completely', async () => {
|
|
const brain = new Brainy({ requireSubtype: false, storage: { type: 'memory' } })
|
|
await brain.init()
|
|
try {
|
|
await brain.add({ data: 'Test', type: 'concept' })
|
|
expect((await brain.find({ type: 'concept' })).length).toBe(1)
|
|
await brain.clear()
|
|
expect((await brain.find({ type: 'concept' })).length).toBe(0)
|
|
} finally {
|
|
await brain.close()
|
|
}
|
|
})
|
|
})
|