Fix actions/tour

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

@@ -0,0 +1,276 @@
+'use strict'
+
+const { assertAsync, illegalKeys } = require('./util')
+
+let db
+
+/**
+ * @param {import('tape')} test
+ */
+exports.setUp = function (test, testCommon) {
+  test('setUp db', function (t) {
+    db = testCommon.factory()
+    db.open(t.end.bind(t))
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.args = function (test, testCommon) {
+  test('test getMany() requires an array argument (callback)', assertAsync.ctx(function (t) {
+    // Add 1 assertion for every assertAsync()
+    t.plan(6)
+
+    db.getMany('foo', assertAsync(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err && err.message, "The first argument 'keys' must be an array")
+    }))
+    db.getMany('foo', {}, assertAsync(function (err) {
+      t.is(err.name, 'TypeError')
+      t.is(err && err.message, "The first argument 'keys' must be an array")
+    }))
+  }))
+
+  test('test getMany() requires an array argument (promise)', 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('test getMany() with illegal keys', assertAsync.ctx(function (t) {
+    // Add 1 assertion for every assertAsync()
+    t.plan(illegalKeys.length * 10)
+
+    for (const { name, key } of illegalKeys) {
+      db.getMany([key], assertAsync(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error (callback)')
+        t.is(err && err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code (callback)')
+      }))
+
+      db.getMany(['valid', key], assertAsync(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error (callback, second key)')
+        t.is(err && err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code (callback, second key)')
+      }))
+
+      db.getMany([key]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error (promise)')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code (promise)')
+      })
+
+      db.getMany(['valid', key]).catch(function (err) {
+        t.ok(err instanceof Error, name + ' - is Error (promise, second key)')
+        t.is(err.code, 'LEVEL_INVALID_KEY', name + ' - correct error code (promise, second key)')
+      })
+    }
+  }))
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.getMany = function (test, testCommon) {
+  test('test simple getMany()', function (t) {
+    db.put('foo', 'bar', function (err) {
+      t.error(err)
+
+      function verify (err, values) {
+        t.error(err)
+        t.ok(Array.isArray(values), 'got an array')
+        t.is(values.length, 1, 'array has 1 element')
+        t.is(values[0], 'bar')
+      }
+
+      db.getMany(['foo'], function (err, values) {
+        verify(err, values)
+
+        db.getMany(['foo'], {}, function (err, values) {
+          verify(err, values)
+
+          db.getMany(['foo'], { valueEncoding: 'utf8' }, function (err, values) {
+            t.error(err)
+            t.is(values && typeof values[0], 'string', 'should be string if not buffer')
+            t.same(values, ['bar'])
+            t.end()
+          })
+        })
+      })
+    })
+  })
+
+  test('test getMany() with multiple keys', function (t) {
+    t.plan(5)
+
+    db.put('beep', 'boop', function (err) {
+      t.ifError(err)
+
+      db.getMany(['foo', 'beep'], { valueEncoding: 'utf8' }, function (err, values) {
+        t.ifError(err)
+        t.same(values, ['bar', 'boop'])
+      })
+
+      db.getMany(['beep', 'foo'], { valueEncoding: 'utf8' }, function (err, values) {
+        t.ifError(err)
+        t.same(values, ['boop', 'bar'], 'maintains order of input keys')
+      })
+    })
+  })
+
+  test('test empty getMany()', assertAsync.ctx(function (t) {
+    const encodings = Object.keys(db.supports.encodings).filter(k => db.supports.encodings[k])
+    t.plan(encodings.length * 3)
+
+    for (const valueEncoding of encodings) {
+      db.getMany([], { valueEncoding }, assertAsync(function (err, values) {
+        t.ifError(err)
+        t.same(values, [])
+      }))
+    }
+  }))
+
+  test('test not-found getMany()', assertAsync.ctx(function (t) {
+    const encodings = Object.keys(db.supports.encodings).filter(k => db.supports.encodings[k])
+    t.plan(encodings.length * 3)
+
+    for (const valueEncoding of encodings) {
+      db.getMany(['nope', 'another'], { valueEncoding }, assertAsync(function (err, values) {
+        t.ifError(err)
+        t.same(values, [undefined, undefined])
+      }))
+    }
+  }))
+
+  test('test getMany() with promise', async function (t) {
+    t.same(await db.getMany(['foo'], { valueEncoding: 'utf8' }), ['bar'])
+    t.same(await db.getMany(['beep'], { valueEncoding: 'utf8' }), ['boop'])
+    t.same(await db.getMany(['foo', 'beep'], { valueEncoding: 'utf8' }), ['bar', 'boop'])
+    t.same(await db.getMany(['beep', 'foo'], { valueEncoding: 'utf8' }), ['boop', 'bar'])
+    t.same(await db.getMany(['beep', 'foo', 'nope'], { valueEncoding: 'utf8' }), ['boop', 'bar', undefined])
+    t.same(await db.getMany([], { valueEncoding: 'utf8' }), [])
+  })
+
+  test('test simultaneous getMany()', function (t) {
+    db.put('hello', 'world', function (err) {
+      t.error(err)
+
+      let completed = 0
+      const done = function () {
+        if (++completed === 20) t.end()
+      }
+
+      for (let i = 0; i < 10; ++i) {
+        db.getMany(['hello'], function (err, values) {
+          t.error(err)
+          t.is(values.length, 1)
+          t.is(values[0] && values[0].toString(), 'world')
+          done()
+        })
+      }
+
+      for (let i = 0; i < 10; ++i) {
+        db.getMany(['not found'], function (err, values) {
+          t.error(err)
+          t.same(values, [undefined])
+          done()
+        })
+      }
+    })
+  })
+
+  test('test getMany() on opening db', assertAsync.ctx(function (t) {
+    t.plan(2 * 2 * 5)
+
+    // Also test empty array because it has a fast-path
+    for (const keys of [['foo'], []]) {
+      // Opening should make no difference, because we call it after getMany()
+      for (const open of [true, false]) {
+        const db = testCommon.factory()
+
+        t.is(db.status, 'opening')
+
+        db.getMany(keys, assertAsync(function (err, values) {
+          t.ifError(err, 'no error')
+          t.same(values, keys.map(_ => undefined))
+        }))
+
+        if (open) {
+          db.open(t.error.bind(t))
+        } else {
+          t.pass()
+        }
+      }
+    }
+  }))
+
+  test('test getMany() on closed db', function (t) {
+    t.plan(2 * 4)
+
+    // Also test empty array because it has a fast-path
+    for (const keys of [['foo'], []]) {
+      const db = testCommon.factory()
+
+      db.open(function (err) {
+        t.ifError(err)
+
+        db.close(assertAsync.with(t, function (err) {
+          t.ifError(err)
+
+          db.getMany(keys, assertAsync(function (err) {
+            t.is(err && err.code, 'LEVEL_DATABASE_NOT_OPEN')
+          }))
+        }))
+      })
+    }
+  })
+
+  test('test getMany() on closing db', function (t) {
+    t.plan(2 * 4)
+
+    // Also test empty array because it has a fast-path
+    for (const keys of [['foo'], []]) {
+      const db = testCommon.factory()
+
+      db.open(assertAsync.with(t, function (err) {
+        t.ifError(err)
+
+        db.close(function (err) {
+          t.ifError(err)
+        })
+
+        db.getMany(keys, assertAsync(function (err) {
+          t.is(err && err.code, 'LEVEL_DATABASE_NOT_OPEN')
+        }))
+      }))
+    }
+  })
+}
+
+/**
+ * @param {import('tape')} test
+ */
+exports.tearDown = function (test, testCommon) {
+  test('tearDown', function (t) {
+    db.close(t.end.bind(t))
+  })
+}
+
+/**
+ * @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)
+}