nolo-cli 0.108.0-alpha.2 → 0.108.1

package/node_modules/abstract-level/test/self/deferred-iterator-test.js

@@ -0,0 +1,314 @@
+'use strict'
+
+const test = require('tape')
+const { DeferredIterator, DeferredKeyIterator, DeferredValueIterator } = require('../../lib/deferred-iterator')
+const { AbstractIterator, AbstractKeyIterator, AbstractValueIterator } = require('../..')
+const { mockLevel } = require('../util')
+const noop = () => {}
+const identity = (v) => v
+
+for (const mode of ['iterator', 'keys', 'values']) {
+  const RealCtor = mode === 'iterator' ? AbstractIterator : mode === 'keys' ? AbstractKeyIterator : AbstractValueIterator
+  const DeferredCtor = mode === 'iterator' ? DeferredIterator : mode === 'keys' ? DeferredKeyIterator : DeferredValueIterator
+  const nextArg = mode === 'iterator' ? ['key', 'value'] : mode === 'keys' ? 'key' : 'value'
+  const privateMethod = '_' + mode
+  const publicMethod = mode
+
+  // NOTE: adapted from deferred-leveldown
+  test(`deferred ${mode}().next()`, async function (t) {
+    t.plan(5)
+
+    const keyEncoding = {
+      format: 'utf8',
+      encode (key) {
+        t.is(key, 'foo', 'encoding got key')
+        return key.toUpperCase()
+      },
+      decode: identity
+    }
+
+    class MockIterator extends RealCtor {
+      async _next () {
+        return nextArg
+      }
+
+      async _close () {}
+    }
+
+    const db = mockLevel({
+      [privateMethod]: function (options) {
+        t.is(options.gt, 'FOO', 'got encoded range option')
+        return new MockIterator(this, options)
+      },
+      async _open (options) {
+        t.pass('opened')
+      }
+    }, { encodings: { utf8: true } }, {
+      keyEncoding
+    })
+
+    const it = db[publicMethod]({ gt: 'foo' })
+    t.ok(it instanceof DeferredCtor, 'is deferred')
+
+    t.is(await it.next(), nextArg)
+    return it.close()
+  })
+
+  // NOTE: adapted from deferred-leveldown
+  test(`deferred ${mode}(): non-deferred operations`, async function (t) {
+    t.plan(3)
+
+    class MockIterator extends RealCtor {
+      _seek (target) {
+        t.is(target, '123')
+      }
+
+      async _next () {
+        return nextArg
+      }
+    }
+
+    const db = mockLevel({
+      [privateMethod]: function (options) {
+        return new MockIterator(this, options)
+      }
+    })
+
+    const it = db[publicMethod]({ gt: 'foo' })
+    t.ok(it instanceof DeferredCtor)
+
+    await db.open()
+    it.seek(123)
+    t.is(await it.next(), nextArg)
+
+    return it.close()
+  })
+
+  // NOTE: adapted from deferred-leveldown
+  test(`deferred ${mode}(): iterators are created in order`, function (t) {
+    t.plan(4)
+
+    const order1 = []
+    const order2 = []
+
+    class MockIterator extends RealCtor {}
+
+    function db (order) {
+      return mockLevel({
+        [privateMethod]: function (options) {
+          order.push('iterator created')
+          return new MockIterator(this, options)
+        },
+        async _put (key, value, options) {
+          order.push('put')
+        }
+      })
+    }
+
+    const db1 = db(order1)
+    const db2 = db(order2)
+
+    db1.open().then(function () {
+      t.same(order1, ['iterator created', 'put'])
+    })
+
+    db2.open().then(function () {
+      t.same(order2, ['put', 'iterator created'])
+    })
+
+    t.ok(db1[publicMethod]() instanceof DeferredCtor)
+    db1.put('key', 'value', noop)
+
+    db2.put('key', 'value', noop)
+    t.ok(db2[publicMethod]() instanceof DeferredCtor)
+  })
+
+  for (const method of ['next', 'nextv', 'all']) {
+    test(`deferred ${mode}(): closed upon failed open, verified by ${method}()`, async function (t) {
+      t.plan(5)
+
+      const db = mockLevel({
+        async _open (options) {
+          t.pass('opening')
+          throw new Error('_open error')
+        },
+        _iterator () {
+          t.fail('should not be called')
+        },
+        [privateMethod] () {
+          t.fail('should not be called')
+        }
+      })
+
+      const it = db[publicMethod]()
+      t.ok(it instanceof DeferredCtor)
+
+      const original = it._close
+      it._close = async function (...args) {
+        t.pass('closed')
+        return original.call(this, ...args)
+      }
+
+      return verifyClosed(t, it, method)
+    })
+
+    test(`deferred ${mode}(): deferred and real iterators are closed on db.close(), verified by ${method}()`, async function (t) {
+      t.plan(7)
+
+      class MockIterator extends RealCtor {
+        async _close () {
+          t.pass('closed')
+        }
+      }
+
+      const db = mockLevel({
+        [privateMethod] (options) {
+          return new MockIterator(this, options)
+        }
+      })
+
+      const it = db[publicMethod]()
+      t.ok(it instanceof DeferredCtor)
+
+      const original = it._close
+      it._close = async function (...args) {
+        t.pass('closed')
+        return original.call(this, ...args)
+      }
+
+      await db.open()
+      await db.close()
+
+      await verifyClosed(t, it, method)
+      await db.open()
+
+      // Should still be closed
+      await verifyClosed(t, it, method)
+
+      return db.close()
+    })
+  }
+
+  test(`deferred ${mode}(): deferred and real iterators are detached on db.close()`, async function (t) {
+    class MockIterator extends RealCtor {}
+
+    let real
+    const db = mockLevel({
+      [privateMethod] (options) {
+        real = new MockIterator(this, options)
+        return real
+      }
+    })
+
+    const it = db[publicMethod]()
+    t.ok(it instanceof DeferredCtor)
+
+    const calls = []
+    const wrap = (obj, name) => {
+      const original = obj.close
+
+      obj.close = async function (...args) {
+        calls.push(name)
+        return original.apply(this, args)
+      }
+    }
+
+    // First open(), to also create the real iterator.
+    await db.open()
+
+    wrap(it, 'deferred')
+    wrap(real, 'real')
+
+    await db.close()
+
+    // There may have been 2 real.close() calls: one by the db closing resources, and
+    // another by the deferred iterator that wraps real. Not relevant for this test.
+    t.same(calls.splice(0, calls.length).slice(0, 2), ['deferred', 'real'])
+
+    // Reopen. Resources should be detached at this point.
+    await db.open()
+    await db.close()
+
+    // So close() should not have been called again.
+    t.same(calls, [], 'no new calls')
+  })
+
+  test(`deferred ${mode}(): defers underlying close()`, function (t) {
+    t.plan(2)
+
+    class MockIterator extends RealCtor {
+      async _close () {
+        order.push('_close')
+      }
+    }
+
+    const order = []
+    const db = mockLevel({
+      async _open (options) {
+        order.push('_open')
+      },
+      [privateMethod] (options) {
+        order.push(privateMethod)
+        return new MockIterator(this, options)
+      }
+    })
+
+    const it = db[publicMethod]()
+    t.ok(it instanceof DeferredCtor)
+
+    it.close().then(function () {
+      t.same(order, ['_open', privateMethod, '_close'])
+    })
+  })
+
+  globalThis.AbortController && test(`deferred ${mode}(): skips real iterator if aborted`, function (t) {
+    t.plan(3)
+
+    const order = []
+    const db = mockLevel({
+      async _open (options) {
+        order.push('_open')
+      },
+      [privateMethod] (options) {
+        t.fail('should not be called')
+      }
+    })
+
+    const ac = new globalThis.AbortController()
+    const it = db[publicMethod]({ signal: ac.signal })
+    t.ok(it instanceof DeferredCtor)
+
+    // Test synchronous call, which should be silently skipped on abort
+    it.seek('foo')
+
+    // Test asynchronous call, which should be rejected
+    it.next().then(t.fail.bind(t, 'should not succeed'), function (err) {
+      t.is(err.code, 'LEVEL_ABORTED')
+    })
+
+    // Signal should prevent real iterator from being created.
+    ac.abort()
+
+    it.close().then(function () {
+      t.same(order, ['_open'])
+    })
+  })
+
+  const verifyClosed = async function (t, it, method) {
+    const requiredArgs = method === 'nextv' ? [10] : []
+
+    try {
+      await it[method](...requiredArgs)
+      t.fail('should not succeed')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN', `correct error on first ${method}()`)
+    }
+
+    try {
+      await it[method](...requiredArgs)
+      t.fail('should not succeed')
+    } catch (err) {
+      t.is(err.code, 'LEVEL_ITERATOR_NOT_OPEN', `correct error on second ${method}()`)
+    }
+  }
+}

package/node_modules/abstract-level/test/self/deferred-operations-test.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const test = require('tape')
+const { mockLevel, mockIterator } = require('../util')
+
+// NOTE: copied from deferred-leveldown
+test('deferred operations are called in order', function (t) {
+  t.plan(3)
+
+  const calls = []
+  const db = mockLevel({
+    async _put (key, value, options) {
+      calls.push({ type: 'put', key, value, options })
+    },
+    async _get (key, options) {
+      calls.push({ type: 'get', key, options })
+    },
+    async _del (key, options) {
+      calls.push({ type: 'del', key, options })
+    },
+    async _batch (arr, options) {
+      calls.push({ type: 'batch', keys: arr.map(op => op.key).join(',') })
+    },
+    async _clear (options) {
+      calls.push({ ...options, type: 'clear' })
+    },
+    _iterator (options) {
+      calls.push({ type: 'iterator' })
+      return mockIterator(this, options, {
+        async _next () {
+          calls.push({ type: 'iterator.next' })
+        }
+      })
+    },
+    async _open (options) {
+      t.is(calls.length, 0, 'not yet called')
+    }
+  }, {
+    encodings: {
+      utf8: true,
+      buffer: true
+    }
+  }, {
+    keyEncoding: 'utf8',
+    valueEncoding: 'utf8'
+  })
+
+  db.open().then(function () {
+    t.same(calls, [
+      { type: 'put', key: '001', value: 'bar1', options: { keyEncoding: 'utf8', valueEncoding: 'utf8' } },
+      { type: 'get', key: '002', options: { keyEncoding: 'utf8', valueEncoding: 'utf8' } },
+      { type: 'clear', reverse: false, limit: -1, keyEncoding: 'utf8' },
+      { type: 'put', key: '010', value: 'bar2', options: { keyEncoding: 'utf8', valueEncoding: 'utf8' } },
+      { type: 'get', key: Buffer.from('011'), options: { keyEncoding: 'buffer', valueEncoding: 'utf8' } },
+      { type: 'del', key: '020', options: { customOption: 123, keyEncoding: 'utf8' } },
+      { type: 'del', key: '021', options: { keyEncoding: 'utf8' } },
+      { type: 'batch', keys: '040,041' },
+      { type: 'iterator' },
+      { type: 'batch', keys: '050,051' },
+      { type: 'iterator.next' },
+      { type: 'clear', gt: '060', reverse: false, limit: -1, keyEncoding: 'utf8' }
+    ], 'calls correctly behaved')
+  })
+
+  // We have dangling promises here, but it's a self test, so no worries.
+  db.put('001', 'bar1')
+  db.get('002')
+  db.clear()
+  db.put('010', 'bar2')
+  db.get('011', { keyEncoding: 'buffer' })
+  db.del('020', { customOption: 123 })
+  db.del('021')
+  db.batch([
+    { type: 'put', key: '040', value: 'a' },
+    { type: 'put', key: '041', value: 'b' }
+  ])
+  const it = db.iterator()
+  db.batch([
+    { type: 'put', key: '050', value: 'c' },
+    { type: 'put', key: '051', value: 'd' }
+  ])
+  it.next()
+  db.clear({ gt: '060' })
+
+  t.is(calls.length, 0, 'not yet called')
+})

package/node_modules/abstract-level/test/self/deferred-queue-test.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const test = require('tape')
+const { DeferredQueue } = require('../../lib/deferred-queue')
+const supported = !!globalThis.AbortController
+
+test('DeferredQueue calls operations in FIFO order', async function (t) {
+  const queue = new DeferredQueue()
+  const calls = []
+
+  queue.add(() => { calls.push(1) })
+  queue.add(() => { calls.push(2) })
+  queue.add(() => { calls.push(3) })
+
+  queue.drain()
+  t.same(calls, [1, 2, 3])
+})
+
+test('DeferredQueue only calls operation once', async function (t) {
+  const queue = new DeferredQueue()
+
+  let calls = 0
+  queue.add(() => { calls++ })
+
+  queue.drain()
+  t.same(calls, 1)
+
+  queue.drain()
+  t.same(calls, 1, 'no new calls')
+})
+
+supported && test('DeferredQueue does not add operation if given an aborted signal', async function (t) {
+  const ac = new globalThis.AbortController()
+  const queue = new DeferredQueue()
+  const calls = []
+
+  ac.abort()
+  queue.add((abortError) => { calls.push(abortError) }, { signal: ac.signal })
+
+  t.is(calls.length, 1)
+  t.is(calls[0].code, 'LEVEL_ABORTED')
+
+  queue.drain()
+  t.is(calls.length, 1, 'not called again')
+})
+
+supported && test('DeferredQueue aborts operation on signal abort', async function (t) {
+  const ac1 = new globalThis.AbortController()
+  const ac2 = new globalThis.AbortController()
+  const queue = new DeferredQueue()
+  const calls = []
+
+  queue.add((abortError) => { calls.push([1, abortError]) }, { signal: ac1.signal })
+  queue.add((abortError) => { calls.push([2, abortError]) }, { signal: ac2.signal })
+  t.is(calls.length, 0, 'not yet called')
+
+  ac1.abort()
+  t.is(calls.length, 1, 'called')
+  t.is(calls[0][0], 1, 'signal1')
+  t.is(calls[0][1].code, 'LEVEL_ABORTED')
+
+  ac2.abort()
+  t.is(calls.length, 2, 'called')
+  t.is(calls[1][0], 2, 'signal2')
+  t.is(calls[1][1].code, 'LEVEL_ABORTED')
+
+  queue.drain()
+  ac2.abort()
+  t.is(calls.length, 2, 'not called again')
+})
+
+supported && test('DeferredQueue calls operation if signal is not aborted', async function (t) {
+  const ac1 = new globalThis.AbortController()
+  const ac2 = new globalThis.AbortController()
+  const queue = new DeferredQueue()
+  const calls = []
+
+  queue.add((abortError) => { calls.push([1, abortError]) }, { signal: ac1.signal })
+  queue.add((abortError) => { calls.push([2, abortError]) }, { signal: ac2.signal })
+  t.is(calls.length, 0, 'not yet called')
+
+  queue.drain()
+  t.is(calls.length, 2, 'called')
+  t.is(calls[0][0], 1, 'signal1')
+  t.is(calls[0][1], undefined, 'no abort error')
+  t.is(calls[1][0], 2, 'signal2')
+  t.is(calls[1][1], undefined, 'no abort error')
+
+  queue.drain()
+  ac1.abort()
+  ac2.abort()
+  t.is(calls.length, 2, 'not called again')
+})