144 lines
3.6 KiB
JavaScript
144 lines
3.6 KiB
JavaScript
'use strict'
|
|
|
|
const input = [{ key: '1', value: '1' }, { key: '2', value: '2' }]
|
|
|
|
let db
|
|
|
|
exports.setup = function (test, testCommon) {
|
|
test('setup', function (t) {
|
|
t.plan(2)
|
|
|
|
db = testCommon.factory()
|
|
db.open(function (err) {
|
|
t.ifError(err, 'no open() error')
|
|
|
|
db.batch(input.map(entry => ({ ...entry, type: 'put' })), function (err) {
|
|
t.ifError(err, 'no batch() error')
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
exports.asyncIterator = function (test, testCommon) {
|
|
for (const mode of ['iterator', 'keys', 'values']) {
|
|
test(`for await...of ${mode}()`, async function (t) {
|
|
t.plan(1)
|
|
|
|
const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
|
|
const output = []
|
|
|
|
for await (const item of it) {
|
|
output.push(item)
|
|
}
|
|
|
|
t.same(output, input.map(({ key, value }) => {
|
|
return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
|
|
}))
|
|
})
|
|
|
|
testCommon.supports.permanence && test(`for await...of ${mode}() (deferred)`, async function (t) {
|
|
t.plan(1)
|
|
|
|
const db = testCommon.factory()
|
|
await db.batch(input.map(entry => ({ ...entry, type: 'put' })))
|
|
await db.close()
|
|
|
|
// Don't await
|
|
db.open()
|
|
|
|
const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
|
|
const output = []
|
|
|
|
for await (const item of it) {
|
|
output.push(item)
|
|
}
|
|
|
|
t.same(output, input.map(({ key, value }) => {
|
|
return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
|
|
}))
|
|
|
|
await db.close()
|
|
})
|
|
|
|
testCommon.supports.snapshots && test(`for await...of ${mode}() (deferred, with snapshot)`, async function (t) {
|
|
t.plan(2)
|
|
|
|
const db = testCommon.factory()
|
|
const it = db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })
|
|
const promise = db.batch(input.map(entry => ({ ...entry, type: 'put' })))
|
|
const output = []
|
|
|
|
for await (const item of it) {
|
|
output.push(item)
|
|
}
|
|
|
|
t.same(output, [], 'used snapshot')
|
|
|
|
// Wait for data to be written
|
|
await promise
|
|
|
|
for await (const item of db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })) {
|
|
output.push(item)
|
|
}
|
|
|
|
t.same(output, input.map(({ key, value }) => {
|
|
return mode === 'iterator' ? [key, value] : mode === 'keys' ? key : value
|
|
}))
|
|
|
|
await db.close()
|
|
})
|
|
|
|
for (const deferred of [false, true]) {
|
|
test(`for await...of ${mode}() (empty, deferred: ${deferred})`, async function (t) {
|
|
const db = testCommon.factory()
|
|
const entries = []
|
|
|
|
if (!deferred) await db.open()
|
|
|
|
for await (const item of db[mode]({ keyEncoding: 'utf8', valueEncoding: 'utf8' })) {
|
|
entries.push(item)
|
|
}
|
|
|
|
t.same(entries, [])
|
|
await db.close()
|
|
})
|
|
}
|
|
|
|
test(`for await...of ${mode}() does not permit reuse`, async function (t) {
|
|
t.plan(3)
|
|
|
|
const it = db[mode]()
|
|
|
|
// eslint-disable-next-line no-unused-vars
|
|
for await (const item of it) {
|
|
t.pass('nexted')
|
|
}
|
|
|
|
try {
|
|
// eslint-disable-next-line no-unused-vars
|
|
for await (const item of it) {
|
|
t.fail('should not be called')
|
|
}
|
|
} catch (err) {
|
|
t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN')
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
exports.teardown = function (test, testCommon) {
|
|
test('teardown', function (t) {
|
|
t.plan(1)
|
|
|
|
db.close(function (err) {
|
|
t.ifError(err, 'no close() error')
|
|
})
|
|
})
|
|
}
|
|
|
|
exports.all = function (test, testCommon) {
|
|
exports.setup(test, testCommon)
|
|
exports.asyncIterator(test, testCommon)
|
|
exports.teardown(test, testCommon)
|
|
}
|