nolo-cli 0.108.0-alpha.2 → 0.108.0

package/node_modules/abstract-level/test/encoding-test.js

@@ -0,0 +1,130 @@
+'use strict'
+
+let db
+let keySequence = 0
+
+const testKey = () => 'test' + (++keySequence)
+
+// TODO: test encoding options on every method. This is largely
+// covered (indirectly) by other tests, but a dedicated property-
+// based test for each would be good to have.
+exports.all = function (test, testCommon) {
+  test('encoding setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+
+  // NOTE: adapted from encoding-down
+  test('encodings default to utf8', function (t) {
+    t.is(db.keyEncoding().commonName, 'utf8')
+    t.is(db.valueEncoding().commonName, 'utf8')
+    t.end()
+  })
+
+  test('can set encoding options in factory', async function (t) {
+    const dbs = []
+
+    for (const name of ['buffer', 'view', 'json']) {
+      if (!testCommon.supports.encodings[name]) continue
+
+      const db1 = testCommon.factory({ keyEncoding: name })
+      const db2 = testCommon.factory({ valueEncoding: name })
+      const db3 = testCommon.factory({ keyEncoding: name, valueEncoding: name })
+
+      t.is(db1.keyEncoding().commonName, name)
+      t.is(db1.keyEncoding(), db1.keyEncoding(name))
+      t.is(db1.valueEncoding().commonName, 'utf8')
+      t.is(db1.valueEncoding(), db1.valueEncoding('utf8'))
+
+      t.is(db2.keyEncoding().commonName, 'utf8')
+      t.is(db2.keyEncoding(), db2.keyEncoding('utf8'))
+      t.is(db2.valueEncoding().commonName, name)
+      t.is(db2.valueEncoding(), db2.valueEncoding(name))
+
+      t.is(db3.keyEncoding().commonName, name)
+      t.is(db3.keyEncoding(), db3.keyEncoding(name))
+      t.is(db3.valueEncoding().commonName, name)
+      t.is(db3.valueEncoding(), db3.valueEncoding(name))
+
+      dbs.push(db1, db2, db3)
+    }
+
+    await Promise.all(dbs.map(db => db.close()))
+  })
+
+  // NOTE: adapted from encoding-down
+  for (const deferred of [false, true]) {
+    test(`default utf8 encoding stringifies numbers (deferred: ${deferred})`, async function (t) {
+      const db = testCommon.factory()
+      if (!deferred) await db.open()
+      await db.put(1, 2)
+      t.is(await db.get(1), '2')
+      testCommon.supports.getSync && t.is(db.getSync(1), '2')
+      return db.close()
+    })
+  }
+
+  // NOTE: adapted from encoding-down
+  test('can decode from string to json', async function (t) {
+    const key = testKey()
+    const data = { thisis: 'json' }
+    await db.put(key, JSON.stringify(data), { valueEncoding: 'utf8' })
+
+    t.same(await db.get(key, { valueEncoding: 'json' }), data, 'got parsed object')
+
+    if (testCommon.supports.getSync) {
+      t.same(db.getSync(key, { valueEncoding: 'json' }), data, 'got parsed object (sync)')
+    }
+  })
+
+  // NOTE: adapted from encoding-down
+  test('can decode from json to string', async function (t) {
+    const data = { thisis: 'json' }
+    const key = testKey()
+    await db.put(key, data, { valueEncoding: 'json' })
+
+    t.same(await db.get(key, { valueEncoding: 'utf8' }), JSON.stringify(data), 'got unparsed JSON string')
+
+    if (testCommon.supports.getSync) {
+      t.same(db.getSync(key, { valueEncoding: 'utf8' }), JSON.stringify(data), 'got unparsed JSON string (sync)')
+    }
+  })
+
+  // NOTE: adapted from encoding-down
+  test('getMany() skips decoding not-found values', async function (t) {
+    t.plan(2)
+
+    const valueEncoding = {
+      encode: JSON.stringify,
+      decode (value) {
+        t.is(value, JSON.stringify(data))
+        return JSON.parse(value)
+      },
+      format: 'utf8'
+    }
+
+    const data = { beep: 'boop' }
+    const key = testKey()
+
+    await db.put(key, data, { valueEncoding })
+    t.same(await db.getMany([key, testKey()], { valueEncoding }), [data, undefined])
+  })
+
+  // NOTE: adapted from memdown
+  test('number keys with utf8 encoding', async function (t) {
+    const db = testCommon.factory()
+    const numbers = [-Infinity, 0, 12, 2, +Infinity]
+
+    await db.open()
+    await db.batch(numbers.map(key => ({ type: 'put', key, value: 'value' })))
+
+    const keys = await db.keys({ keyEncoding: 'utf8' }).all()
+    t.same(keys, numbers.map(String), 'sorts lexicographically')
+
+    return db.close()
+  })
+
+  test('encoding teardown', async function (t) {
+    return db.close()
+  })
+}

package/node_modules/abstract-level/test/events/write.js

@@ -0,0 +1,132 @@
+'use strict'
+
+module.exports = function (test, testCommon) {
+  for (const deferred of [false, true]) {
+    // Chained batch does not support deferred open
+    const batchMethods = deferred ? ['batch'] : ['batch', 'chained batch']
+    const allMethods = batchMethods.concat(['singular'])
+
+    for (const method of allMethods) {
+      // db.put() and db.del() do not support the sublevel option
+      for (const withSublevel of (method === 'singular' ? [false] : [false, true])) {
+        test(`db emits write event for ${method} put operation (deferred: ${deferred}, sublevel: ${withSublevel})`, async function (t) {
+          t.plan(1)
+
+          const db = testCommon.factory()
+          const sublevel = withSublevel ? db.sublevel('abc') : null
+
+          if (!deferred) {
+            await db.open()
+            if (withSublevel) await sublevel.open()
+          }
+
+          // Note: may return a transcoder encoding, which unfortunately makes the below
+          // assertions a little less precise (i.e. we can't compare output data). But
+          // in places where we expect encoded data, we can use strings (rather than
+          // numbers) as the input to encode(), which'll tell us that encoding did happen.
+          const dbEncoding = db.keyEncoding('utf8')
+          const subEncoding = withSublevel ? sublevel.keyEncoding('utf8') : null
+
+          db.on('write', function (ops) {
+            t.same(ops, [
+              {
+                type: 'put',
+                key: withSublevel ? sublevel.prefixKey(subEncoding.encode('456'), subEncoding.format, true) : 456,
+                value: withSublevel ? subEncoding.encode('99') : 99,
+                keyEncoding: db.keyEncoding(withSublevel ? subEncoding.format : 'utf8'),
+                valueEncoding: db.valueEncoding(withSublevel ? subEncoding.format : 'utf8'),
+                encodedKey: withSublevel ? sublevel.prefixKey(subEncoding.encode('456'), subEncoding.format, true) : dbEncoding.encode('456'),
+                encodedValue: (withSublevel ? subEncoding : dbEncoding).encode('99'),
+                custom: 123,
+                sublevel: null // Should be unset
+              }
+            ], 'got write event')
+          })
+
+          switch (method) {
+            case 'batch':
+              await db.batch([{ type: 'put', key: 456, value: 99, custom: 123, sublevel }])
+              break
+            case 'chained batch':
+              await db.batch().put(456, 99, { custom: 123, sublevel }).write()
+              break
+            case 'singular':
+              // Does not support sublevel option
+              await db.put(456, 99, { custom: 123, sublevel })
+              break
+          }
+
+          return db.close()
+        })
+
+        test(`db emits write event for ${method} del operation (deferred: ${deferred}, sublevel: ${withSublevel})`, async function (t) {
+          t.plan(1)
+
+          const db = testCommon.factory()
+          const sublevel = withSublevel ? db.sublevel('abc') : null
+
+          if (!deferred) {
+            await db.open()
+            if (withSublevel) await sublevel.open()
+          }
+
+          // See notes above, in the put test
+          const dbEncoding = db.keyEncoding('utf8')
+          const subEncoding = withSublevel ? sublevel.keyEncoding('utf8') : null
+
+          db.on('write', function (ops) {
+            t.same(ops, [
+              {
+                type: 'del',
+                key: withSublevel ? sublevel.prefixKey(subEncoding.encode('456'), subEncoding.format, true) : 456,
+                keyEncoding: db.keyEncoding(withSublevel ? subEncoding.format : 'utf8'),
+                encodedKey: withSublevel ? sublevel.prefixKey(subEncoding.encode('456'), subEncoding.format, true) : dbEncoding.encode('456'),
+                custom: 123,
+                sublevel: null // Should be unset
+              }
+            ], 'got write event')
+          })
+
+          switch (method) {
+            case 'batch':
+              await db.batch([{ type: 'del', key: 456, custom: 123, sublevel }])
+              break
+            case 'chained batch':
+              await db.batch().del(456, { custom: 123, sublevel }).write()
+              break
+            case 'singular':
+              // Does not support sublevel option
+              await db.del(456, { custom: 123, sublevel })
+              break
+          }
+
+          return db.close()
+        })
+      }
+    }
+
+    for (const method of batchMethods) {
+      test(`db emits write event for multiple ${method} operations (deferred: ${deferred})`, async function (t) {
+        t.plan(1)
+
+        const db = testCommon.factory()
+        if (!deferred) await db.open()
+
+        db.on('write', function (ops) {
+          t.same(ops.map(op => op.key), ['a', 'b'], 'got multiple operations in one event')
+        })
+
+        switch (method) {
+          case 'batch':
+            await db.batch([{ type: 'put', key: 'a', value: 'foo' }, { type: 'del', key: 'b' }])
+            break
+          case 'chained batch':
+            await db.batch().put('a', 'foo').del('b').write()
+            break
+        }
+
+        return db.close()
+      })
+    }
+  }
+}

package/node_modules/abstract-level/test/factory-test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = function (test, testCommon) {
+  test('testCommon.factory() returns valid database', function (t) {
+    t.plan(6)
+
+    const db = testCommon.factory()
+    const kEvent = Symbol('event')
+
+    // Avoid instanceof, for levelup compatibility tests
+    t.is(typeof db, 'object', 'is an object')
+    t.isNot(db, null, 'is not null')
+    t.is(typeof db.open, 'function', 'has open() method')
+    t.is(typeof db.on, 'function', 'has on() method')
+    t.is(typeof db.emit, 'function', 'has emit() method')
+
+    db.once(kEvent, (v) => t.is(v, 'foo', 'got event'))
+    db.emit(kEvent, 'foo')
+  })
+
+  test('testCommon.factory() returns a unique database', async function (t) {
+    const db1 = testCommon.factory()
+    const db2 = testCommon.factory()
+
+    t.isNot(db1, db2, 'unique instances')
+
+    await db1.open()
+    await db2.open()
+    await db1.put('key', 'value')
+
+    const value = await db2.get('key')
+    t.is(value, undefined, 'db2 should be empty')
+
+    return Promise.all([db1.close(), db2.close()])
+  })
+}

package/node_modules/abstract-level/test/get-many-test.js

@@ -0,0 +1,157 @@
+'use strict'
+
+const { illegalKeys, assertPromise } = require('./util')
+const traits = require('./traits')
+
+let db
+
+/**
+ * @param {import('tape')} test
+ */
+exports.setUp = function (test, testCommon) {
+  test('getMany() setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.args = function (test, testCommon) {
+  test('getMany() requires an array argument', function (t) {
+    t.plan(6)
+
+    db.getMany().catch(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err && err.message, "The first argument 'keys' must be an array")
+    })
+
+    db.getMany('foo').catch(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err && err.message, "The first argument 'keys' must be an array")
+    })
+
+    db.getMany('foo', {}).catch(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err && err.message, "The first argument 'keys' must be an array")
+    })
+  })
+
+  test('getMany() with illegal keys', function (t) {
+    t.plan(illegalKeys.length * 4)
+
+    for (const { name, key } of illegalKeys) {
+      db.getMany([key]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code')
+      })
+
+      db.getMany(['valid', key]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error (second key)')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code (second key)')
+      })
+    }
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.getMany = function (test, testCommon) {
+  test('simple getMany()', async function (t) {
+    await db.put('foo', 'bar')
+
+    t.same(await assertPromise(db.getMany(['foo'])), ['bar'])
+    t.same(await db.getMany(['foo'], {}), ['bar']) // same but with {}
+    t.same(await db.getMany(['foo'], { valueEncoding: 'utf8' }), ['bar'])
+  })
+
+  test('getMany() with multiple keys', async function (t) {
+    await db.put('beep', 'boop')
+
+    t.same(await db.getMany(['foo', 'beep']), ['bar', 'boop'])
+    t.same(await db.getMany(['beep', 'foo']), ['boop', 'bar'], 'maintains order of input keys')
+  })
+
+  test('empty getMany()', async function (t) {
+    t.same(await db.getMany([]), [])
+
+    const encodings = Object.keys(db.supports.encodings)
+      .filter(k => db.supports.encodings[k])
+
+    for (const valueEncoding of encodings) {
+      t.same(await db.getMany([], { valueEncoding }), [])
+    }
+  })
+
+  test('getMany() on non-existent keys', async function (t) {
+    t.same(await db.getMany(['nope', 'another']), [undefined, undefined])
+    t.same(await db.getMany(['beep', 'another']), ['boop', undefined])
+    t.same(await db.getMany(['nope', 'beep', Math.random()]), [undefined, 'boop', undefined])
+
+    const encodings = Object.keys(db.supports.encodings)
+      .filter(k => db.supports.encodings[k])
+
+    for (const valueEncoding of encodings) {
+      t.same(await db.getMany(['nope', 'another'], { valueEncoding }), [undefined, undefined])
+    }
+  })
+
+  test('simultaneous getMany()', async function (t) {
+    t.plan(20)
+
+    await db.put('hello', 'world')
+    const promises = []
+
+    for (let i = 0; i < 10; ++i) {
+      promises.push(db.getMany(['hello']).then(function (values) {
+        t.same(values, ['world'])
+      }))
+    }
+
+    for (let i = 0; i < 10; ++i) {
+      promises.push(db.getMany(['non-existent']).then(function (values) {
+        t.same(values, [undefined])
+      }))
+    }
+
+    return Promise.all(promises)
+  })
+
+  traits.open('getMany()', testCommon, async function (t, db) {
+    t.same(await assertPromise(db.getMany(['foo'])), [undefined])
+  })
+
+  traits.closed('getMany()', testCommon, async function (t, db) {
+    return db.getMany(['foo'])
+  })
+
+  // Also test empty array because it has a fast-path
+  traits.open('getMany() with empty array', testCommon, async function (t, db) {
+    t.same(await assertPromise(db.getMany([])), [])
+  })
+
+  traits.closed('getMany() with empty array', testCommon, async function (t, db) {
+    return db.getMany([])
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.tearDown = function (test, testCommon) {
+  test('getMany() teardown', async function (t) {
+    return db.close()
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.getMany(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

package/node_modules/abstract-level/test/get-sync-test.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { illegalKeys } = require('./util')
+const traits = require('./traits')
+
+let db
+
+exports.setUp = function (test, testCommon) {
+  test('getSync() setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('getSync() with illegal keys', function (t) {
+    t.plan(illegalKeys.length * 2)
+
+    for (const { name, key } of illegalKeys) {
+      try {
+        db.getSync(key)
+      } catch (err) {
+        t.ok(err instanceof Error, name + ' - is Error')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code')
+      }
+    }
+  })
+}
+
+exports.getSync = function (test, testCommon) {
+  test('simple getSync()', async function (t) {
+    await db.put('foo', 'bar')
+
+    t.is(db.getSync('foo'), 'bar')
+    t.is(db.getSync('foo', {}), 'bar') // same but with {}
+    t.is(db.getSync('foo', { valueEncoding: 'utf8' }), 'bar')
+  })
+
+  test('getSync() on non-existent key', async function (t) {
+    for (const key of ['non-existent', Math.random()]) {
+      t.is(db.getSync(key), undefined, 'not found')
+    }
+  })
+
+  traits.closed('getSync()', testCommon, async function (t, db) {
+    db.getSync('foo')
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('getSync() teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.getSync(test, testCommon)
+  exports.tearDown(test, testCommon)
+}

package/node_modules/abstract-level/test/get-test.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { illegalKeys, assertPromise } = require('./util')
+const traits = require('./traits')
+
+let db
+
+exports.setUp = function (test, testCommon) {
+  test('get() setup', async function (t) {
+    db = testCommon.factory()
+    return db.open()
+  })
+}
+
+exports.args = function (test, testCommon) {
+  test('get() with illegal keys', function (t) {
+    t.plan(illegalKeys.length * 2)
+
+    for (const { name, key } of illegalKeys) {
+      db.get(key).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code')
+      })
+    }
+  })
+}
+
+exports.get = function (test, testCommon) {
+  test('simple get()', async function (t) {
+    await db.put('foo', 'bar')
+    t.is(await assertPromise(db.get('foo')), 'bar')
+    t.is(await db.get('foo', {}), 'bar') // same but with {}
+    t.is(await db.get('foo', { valueEncoding: 'utf8' }), 'bar')
+  })
+
+  test('get() on non-existent key', async function (t) {
+    for (const key of ['non-existent', Math.random()]) {
+      t.is(await assertPromise(db.get(key)), undefined, 'not found')
+    }
+  })
+
+  test('simultaneous get()', async function (t) {
+    t.plan(20)
+
+    await db.put('hello', 'world')
+    const promises = []
+
+    for (let i = 0; i < 10; ++i) {
+      promises.push(db.get('hello').then((value) => {
+        t.is(value, 'world')
+      }))
+    }
+
+    for (let i = 0; i < 10; ++i) {
+      promises.push(db.get('non-existent').then((value) => {
+        t.is(value, undefined, 'not found')
+      }))
+    }
+
+    return Promise.all(promises)
+  })
+
+  traits.open('get()', testCommon, async function (t, db) {
+    t.is(await assertPromise(db.get('foo')), undefined, 'void promise')
+  })
+
+  traits.closed('get()', testCommon, async function (t, db) {
+    return db.get('foo')
+  })
+}
+
+exports.tearDown = function (test, testCommon) {
+  test('get() teardown', async function (t) {
+    return db.close()
+  })
+}
+
+exports.all = function (test, testCommon) {
+  exports.setUp(test, testCommon)
+  exports.args(test, testCommon)
+  exports.get(test, testCommon)
+  exports.tearDown(test, testCommon)
+}