logigate/tests/durability.test.ts

150 lines
6.5 KiB
TypeScript
Raw Permalink Normal View History

import { execFileSync } from 'node:child_process'
import { existsSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
import { mkdir, readFile, rm, unlink, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import { backupName, pruneBackups, writeBackup } from '../server/utils/backup'
import { versionsToDrop } from '../server/utils/history'
import { atomicWrite, removeStaleTemp, safeFsDriver, safeRead } from '../server/utils/safe-fs'
let dir = ''
beforeEach(() => {
dir = mkdtempSync(join(tmpdir(), 'logigate-'))
})
afterEach(async () => {
await rm(dir, { recursive: true, force: true })
})
describe('crash-safe files', () => {
it('keeps the previous good version as .bak', async () => {
const f = join(dir, 'a', 'p.json')
await atomicWrite(f, '{"v":1}')
await atomicWrite(f, '{"v":2}')
expect(await safeRead(f)).toBe('{"v":2}')
expect(await readFile(`${f}.bak`, 'utf8')).toBe('{"v":1}')
})
it('reads the .bak when the file was cut off by a power failure', async () => {
const f = join(dir, 'p.json')
await atomicWrite(f, '{"v":1}')
await atomicWrite(f, '{"v":2}')
await writeFile(f, '{"v":3, "nodes": [{"id": "n1", "ki') // truncated
expect(await safeRead(f)).toBe('{"v":1}')
})
it('reads the .bak when the power went out between the two renames', async () => {
const f = join(dir, 'p.json')
await atomicWrite(f, '{"v":1}')
await atomicWrite(f, '{"v":2}')
await unlink(f)
expect(await safeRead(f)).toBe('{"v":1}')
})
it('ignores a half-written temporary file and cleans it up', async () => {
const f = join(dir, 'p.json')
await atomicWrite(f, '{"v":1}')
await writeFile(`${f}.tmp-123-456-abc`, '{"v":2, "trunc')
expect(await safeRead(f)).toBe('{"v":1}')
await removeStaleTemp(dir)
expect(readdirSync(dir).sort()).toEqual(['p.json'])
})
it('does not overwrite a good .bak with a damaged file', async () => {
const f = join(dir, 'p.json')
await atomicWrite(f, '{"v":1}')
await atomicWrite(f, '{"v":2}')
await writeFile(f, 'garbage')
await atomicWrite(f, '{"v":3}')
expect(await readFile(`${f}.bak`, 'utf8')).toBe('{"v":1}')
expect(await safeRead(f)).toBe('{"v":3}')
})
it('works as a storage driver: keys by prefix, without .bak and temp files', async () => {
const d = safeFsDriver({ base: dir })
await d.setItem('u1:index', '{"projects":[]}')
await d.setItem('u1:p:abc', '{"name":"A"}')
await d.setItem('u1:p:abc', '{"name":"B"}')
await d.setItem('u2:index', '{}')
await writeFile(join(dir, 'u1', 'p', 'abc.tmp-1-2-x'), 'x')
expect((await d.getKeys('u1:')).sort()).toEqual(['u1:index', 'u1:p:abc'])
expect(await d.getItem('u1:p:abc')).toBe('{"name":"B"}')
expect(await d.hasItem('u1:p:nope')).toBe(false)
await d.removeItem('u1:p:abc')
expect(await d.hasItem('u1:p:abc')).toBe(false)
expect(() => d.getItem('u1:..:x')).toThrow()
})
it('reads files written by the old storage the same way', async () => {
await mkdir(join(dir, 'user'), { recursive: true })
writeFileSync(join(dir, 'user', 'abc'), '{"id":"abc","email":"a@b.c"}')
const d = safeFsDriver({ base: dir })
expect(await d.getItem('user:abc')).toBe('{"id":"abc","email":"a@b.c"}')
})
})
describe('savegames', () => {
const DAY = 86_400_000
const now = Date.UTC(2026, 9, 20, 12)
it('keeps the newest 30 versions', () => {
const times = Array.from({ length: 40 }, (_, i) => now - i * 60_000)
const drop = versionsToDrop(times, now)
// All on one day, whose last version is among the newest anyway.
expect(drop).toEqual(times.slice(30))
})
it('keeps the last version of each day for 90 days, nothing older', () => {
const times = [now, ...Array.from({ length: 100 }, (_, i) => now - (i + 1) * DAY - 3_600_000), ...Array.from({ length: 100 }, (_, i) => now - (i + 1) * DAY - 7_200_000)]
const drop = new Set(versionsToDrop(times, now))
const sorted = [...times].sort((a, b) => b - a)
const older = sorted.slice(30).filter(t => !drop.has(t))
// Beyond the newest 30: one per day, none older than 90 days.
expect(new Set(older.map(t => new Date(t).toISOString().slice(0, 10))).size).toBe(older.length)
expect(older.every(t => now - t <= 90 * DAY)).toBe(true)
expect(older.length).toBeGreaterThan(70)
})
})
describe('daily backup', () => {
it('backs up every file and restores it with the script', async () => {
const data = join(dir, 'data')
const backups = join(dir, 'backups')
await atomicWrite(join(data, 'users', 'user', 'u1'), '{"id":"u1"}')
await atomicWrite(join(data, 'accounts', 'u1', 'index'), '{"projects":[]}')
await atomicWrite(join(data, 'accounts', 'u1', 'p', 'abc'), '{"name":"v1"}')
await atomicWrite(join(data, 'accounts', 'u1', 'p', 'abc'), '{"name":"v2"}')
await writeFile(join(data, 'accounts', 'u1', 'broken'), '{"half')
await atomicWrite(join(data, 'shares', 'X'), '{"project":0}')
await atomicWrite(join(data, 'shares', 'X'), '{"project":1}')
await unlink(join(data, 'shares', 'X')) // crash between renames: only X.bak (the previous version) left
const { file, count } = await writeBackup(data, backups, new Date(Date.UTC(2026, 9, 20)))
expect(file.endsWith(backupName(new Date(Date.UTC(2026, 9, 20))))).toBe(true)
expect(count).toBe(4)
const target = join(dir, 'restored')
execFileSync('node', ['scripts/restore-backup.mjs', file, target])
const read = (p: string) => readFileSync(join(target, p), 'utf8')
expect(read('users/user/u1')).toBe('{"id":"u1"}')
expect(read('accounts/u1/p/abc')).toBe('{"name":"v2"}')
expect(read('shares/X')).toBe('{"project":0}')
expect(existsSync(join(target, 'accounts', 'u1', 'broken'))).toBe(false)
})
it('keeps 14 daily backups and one per month', async () => {
await mkdir(dir, { recursive: true })
for (let i = 0; i < 60; i++) {
const d = new Date(Date.UTC(2026, 9, 20) - i * 86_400_000)
writeFileSync(join(dir, backupName(d)), '')
}
await pruneBackups(dir)
const left = readdirSync(dir).sort()
expect(left).toContain(backupName(new Date(Date.UTC(2026, 9, 20))))
expect(left).toContain(backupName(new Date(Date.UTC(2026, 7, 22))))
expect(left).toContain(backupName(new Date(Date.UTC(2026, 8, 1))))
expect(left).toContain(backupName(new Date(Date.UTC(2026, 9, 1))))
expect(left.length).toBe(14 + 3) // 14 newest + first of October, September, August
})
})