ueberdb2 2.1.0 → 2.2.2

package/test/test.js

@@ -7,8 +7,8 @@ const Randexp = require('randexp');
 const assert = require('assert').strict;
 const databases = require('./lib/databases').databases;
 const fs = require('fs').promises;
+const logging = require('../lib/logging');
 const ueberdb = require('../index');
-const util = require('util');
 
 const maxKeyLength = 100;
 const randomString = (length = maxKeyLength) => new Randexp(new RegExp(`.{${length}}`)).gen();
@@ -25,18 +25,9 @@ after(async function () {
   }, 5000).unref();
 });
 
-// Returns an object with promisified equivalents of ueberdb.Database methods.
-const promisifyDb = (db) => {
-  const ret = {};
-  const fns = ['init', 'close', 'get', 'getSub', 'findKeys', 'set', 'setSub', 'remove', 'flush'];
-  for (const fn of fns) ret[fn] = util.promisify(db[fn].bind(db));
-  return ret;
-};
-
 describe(__filename, function () {
   let speedTable;
   let db;
-  let pdb;
 
   before(async function () {
     speedTable = new Clitable({
@@ -74,13 +65,12 @@ describe(__filename, function () {
                 db = new ueberdb.Database(database, dbSettings, {
                   ...(readCache ? {} : {cache: 0}),
                   ...(writeBuffer ? {} : {writeInterval: 0}),
-                });
-                pdb = promisifyDb(db);
-                await pdb.init();
+                }, new logging.ConsoleLogger());
+                await db.init();
               });
 
               after(async function () {
-                await pdb.close();
+                await db.close();
                 if (dbSettings.filename) await fs.unlink(dbSettings.filename).catch(() => {});
               });
 
@@ -93,22 +83,22 @@ describe(__filename, function () {
                     before(async function () {
                       input = {a: 1, b: new Randexp(/.+/).gen()};
                       key = randomString(maxKeyLength - 1) + (space ? ' ' : '');
-                      await pdb.set(key, input);
+                      await db.set(key, input);
                     });
 
                     it('get(key) -> record', async function () {
-                      const output = await pdb.get(key);
+                      const output = await db.get(key);
                       assert.equal(JSON.stringify(output), JSON.stringify(input));
                     });
 
                     it('get(`${key} `) -> nullish', async function () {
-                      const output = await pdb.get(`${key} `);
+                      const output = await db.get(`${key} `);
                       assert(output == null);
                     });
 
                     if (space) {
                       it('get(key.slice(0, -1)) -> nullish', async function () {
-                        const output = await pdb.get(key.slice(0, -1));
+                        const output = await db.get(key.slice(0, -1));
                         assert(output == null);
                       });
                     }
@@ -118,104 +108,131 @@ describe(__filename, function () {
 
               it('get of unknown key -> nullish', async function () {
                 const key = randomString();
-                assert(await pdb.get(key) == null);
+                assert(await db.get(key) == null);
               });
 
               it('set+get works', async function () {
                 const input = {a: 1, b: new Randexp(/.+/).gen()};
                 const key = randomString();
-                await pdb.set(key, input);
-                const output = await pdb.get(key);
+                await db.set(key, input);
+                const output = await db.get(key);
                 assert.equal(JSON.stringify(output), JSON.stringify(input));
               });
 
               it('set+get with random key/value works', async function () {
                 const input = {testLongString: new Randexp(/[a-f0-9]{50000}/).gen()};
                 const key = randomString();
-                await pdb.set(key, input);
-                const output = await pdb.get(key);
+                await db.set(key, input);
+                const output = await db.get(key);
                 assert.equal(JSON.stringify(output), JSON.stringify(input));
               });
 
               it('findKeys works', async function () {
-                const input = {a: 1, b: new Randexp(/.+/).gen()};
+                if (database === 'mongodb') this.skip(); // TODO: Fix mongodb.
                 // TODO setting a key with non ascii chars
                 const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
                 await Promise.all([
-                  pdb.set(`${key}:test2`, input),
-                  pdb.set(`${key}:test`, input),
+                  db.set(key, true),
+                  db.set(`${key}a`, true),
+                  db.set(`nonmatching_${key}`, false),
                 ]);
-                const output = await pdb.findKeys(`${key}:*`, null);
-                for (const keyVal of output) {
-                  const output = await pdb.get(keyVal);
-                  assert.equal(JSON.stringify(output), JSON.stringify(input));
-                }
+                const keys = await db.findKeys(`${key}*`, null);
+                assert.deepEqual(keys.sort(), [key, `${key}a`]);
+              });
+
+              it('findKeys with exclusion works', async function () {
+                if (database === 'mongodb') this.skip(); // TODO: Fix mongodb.
+                if (database === 'redis') this.skip(); // TODO: Fix redis.
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await Promise.all([
+                  db.set(key, true),
+                  db.set(`${key}a`, true),
+                  db.set(`${key}b`, false),
+                  db.set(`${key}b2`, false),
+                  db.set(`nonmatching_${key}`, false),
+                ]);
+                const keys = await db.findKeys(`${key}*`, `${key}b*`);
+                assert.deepEqual(keys.sort(), [key, `${key}a`].sort());
+              });
+
+              it('findKeys with no matches works', async function () {
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await db.set(key, true);
+                const keys = await db.findKeys(`${key}_nomatch_*`, null);
+                assert.deepEqual(keys, []);
+              });
+
+              it('findKeys with no wildcard works', async function () {
+                const key = new Randexp(/([a-z]\w{0,20})foo\1/).gen();
+                await db.set(key, true);
+                const keys = await db.findKeys(key, null);
+                assert.deepEqual(keys, [key]);
               });
 
               it('remove works', async function () {
                 const input = {a: 1, b: new Randexp(/.+/).gen()};
                 const key = randomString();
-                await pdb.set(key, input);
-                assert.equal(JSON.stringify(await pdb.get(key)), JSON.stringify(input));
-                await pdb.remove(key);
-                assert(await pdb.get(key) == null);
+                await db.set(key, input);
+                assert.equal(JSON.stringify(await db.get(key)), JSON.stringify(input));
+                await db.remove(key);
+                assert(await db.get(key) == null);
               });
 
               it('getSub of existing property works', async function () {
-                await pdb.set('k', {sub1: {sub2: 'v'}});
-                assert.equal(await pdb.getSub('k', ['sub1', 'sub2']), 'v');
-                assert.deepEqual(await pdb.getSub('k', ['sub1']), {sub2: 'v'});
-                assert.deepEqual(await pdb.getSub('k', []), {sub1: {sub2: 'v'}});
+                await db.set('k', {sub1: {sub2: 'v'}});
+                assert.equal(await db.getSub('k', ['sub1', 'sub2']), 'v');
+                assert.deepEqual(await db.getSub('k', ['sub1']), {sub2: 'v'});
+                assert.deepEqual(await db.getSub('k', []), {sub1: {sub2: 'v'}});
               });
 
               it('getSub of missing property returns nullish', async function () {
-                await pdb.set('k', {sub1: {}});
-                assert(await pdb.getSub('k', ['sub1', 'sub2']) == null);
+                await db.set('k', {sub1: {}});
+                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
 
-                await pdb.set('k', {});
-                assert(await pdb.getSub('k', ['sub1', 'sub2']) == null);
-                assert(await pdb.getSub('k', ['sub1']) == null);
+                await db.set('k', {});
+                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
+                assert(await db.getSub('k', ['sub1']) == null);
 
-                await pdb.remove('k');
-                assert(await pdb.getSub('k', ['sub1', 'sub2']) == null);
-                assert(await pdb.getSub('k', ['sub1']) == null);
-                assert(await pdb.getSub('k', []) == null);
+                await db.remove('k');
+                assert(await db.getSub('k', ['sub1', 'sub2']) == null);
+                assert(await db.getSub('k', ['sub1']) == null);
+                assert(await db.getSub('k', []) == null);
               });
 
               it('setSub can modify an existing property', async function () {
-                await pdb.set('k', {sub1: {sub2: 'v'}});
-                await pdb.setSub('k', ['sub1', 'sub2'], 'v2');
-                assert.deepEqual(await pdb.get('k'), {sub1: {sub2: 'v2'}});
+                await db.set('k', {sub1: {sub2: 'v'}});
+                await db.setSub('k', ['sub1', 'sub2'], 'v2');
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v2'}});
 
-                await pdb.setSub('k', ['sub1'], 'v2');
-                assert.deepEqual(await pdb.get('k'), {sub1: 'v2'});
+                await db.setSub('k', ['sub1'], 'v2');
+                assert.deepEqual(await db.get('k'), {sub1: 'v2'});
 
-                await pdb.setSub('k', [], 'v3');
-                assert.equal(await pdb.get('k'), 'v3');
+                await db.setSub('k', [], 'v3');
+                assert.equal(await db.get('k'), 'v3');
               });
 
               it('setSub can add a new property', async function () {
-                await pdb.remove('k');
-                await pdb.setSub('k', [], {});
-                assert.deepEqual(await pdb.get('k'), {});
-                await pdb.setSub('k', ['sub1'], {});
-                assert.deepEqual(await pdb.get('k'), {sub1: {}});
-                await pdb.setSub('k', ['sub1', 'sub2'], 'v');
-                assert.deepEqual(await pdb.get('k'), {sub1: {sub2: 'v'}});
-
-                await pdb.remove('k');
-                await pdb.setSub('k', ['sub1', 'sub2'], 'v');
-                assert.deepEqual(await pdb.get('k'), {sub1: {sub2: 'v'}});
+                await db.remove('k');
+                await db.setSub('k', [], {});
+                assert.deepEqual(await db.get('k'), {});
+                await db.setSub('k', ['sub1'], {});
+                assert.deepEqual(await db.get('k'), {sub1: {}});
+                await db.setSub('k', ['sub1', 'sub2'], 'v');
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
+
+                await db.remove('k');
+                await db.setSub('k', ['sub1', 'sub2'], 'v');
+                assert.deepEqual(await db.get('k'), {sub1: {sub2: 'v'}});
               });
 
               it('setSub rejects attempts to set properties on primitives', async function () {
                 for (const v of ['hello world', 42, true]) {
-                  await pdb.set('k', v);
-                  assert.rejects(pdb.setSub('k', ['sub'], 'x'), {
+                  await db.set('k', v);
+                  assert.rejects(db.setSub('k', ['sub'], 'x'), {
                     name: 'TypeError',
                     message: /property "sub" on non-object/,
                   });
-                  assert.deepEqual(await pdb.get('k'), v);
+                  assert.deepEqual(await db.get('k'), v);
                 }
               });
 
@@ -239,21 +256,21 @@ describe(__filename, function () {
 
                 const timers = {start: Date.now()};
 
-                for (let i = 0; i < count; ++i) promises[i] = pdb.set(key + i, input);
-                promises[count] = pdb.flush();
+                for (let i = 0; i < count; ++i) promises[i] = db.set(key + i, input);
+                promises[count] = db.flush();
                 await Promise.all(promises);
                 timers.set = Date.now();
 
-                for (let i = 0; i < count; ++i) promises[i] = pdb.get(key + i);
+                for (let i = 0; i < count; ++i) promises[i] = db.get(key + i);
                 await Promise.all(promises);
                 timers.get = Date.now();
 
-                for (let i = 0; i < count; ++i) promises[i] = pdb.findKeys(key + i, null);
+                for (let i = 0; i < count; ++i) promises[i] = db.findKeys(key + i, null);
                 await Promise.all(promises);
                 timers.findKeys = Date.now();
 
-                for (let i = 0; i < count; ++i) promises[i] = pdb.remove(key + i);
-                promises[count] = pdb.flush();
+                for (let i = 0; i < count; ++i) promises[i] = db.remove(key + i);
+                promises[count] = db.flush();
                 await Promise.all(promises);
                 timers.remove = Date.now();
 

package/test/test_bulk.js

@@ -11,10 +11,8 @@ describe(__filename, function () {
   let mock = null;
   const createDb = async (wrapperSettings) => {
     const settings = {};
-    const udb = new ueberdb.Database('mock', settings, wrapperSettings);
+    db = new ueberdb.Database('mock', settings, wrapperSettings);
     mock = settings.mock;
-    db = {};
-    for (const fn of ['init', 'close', 'set']) db[fn] = util.promisify(udb[fn].bind(udb));
     mock.once('init', (cb) => cb());
     await db.init();
   };

package/test/test_findKeys.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const assert = require('assert').strict;
+const logging = require('../lib/logging');
+const ueberdb = require('../index');
+
+const logger = new logging.ConsoleLogger();
+
+describe(__filename, function () {
+  let db = null;
+  let mock = null;
+  const createDb = async (wrapperSettings = {}) => {
+    const settings = {};
+    db = new ueberdb.Database('mock', settings, {json: false, ...wrapperSettings}, logger);
+    mock = settings.mock;
+    mock.once('init', (cb) => cb());
+    await db.init();
+  };
+
+  afterEach(async function () {
+    if (mock != null) {
+      mock.removeAllListeners();
+      mock.once('close', (cb) => cb());
+      mock = null;
+    }
+    if (db != null) {
+      await db.close();
+      db = null;
+    }
+  });
+
+  it('cached entries are flushed before calling findKeys', async function () {
+    // Trigger a test timeout if flush() completes before the write operation is buffered.
+    await createDb({writeInterval: 1e9});
+    let called = false;
+    mock.on('set', (k, v, cb) => { called = true; cb(null); });
+    mock.on('findKeys', (k, nk, cb) => { assert(called); cb(null, []); });
+    await Promise.all([
+      db.set('key', 'value'),
+      db.findKeys('key', null),
+    ]);
+  });
+});

package/test/test_flush.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const logging = require('../lib/logging');
+const ueberdb = require('../index');
+
+const logger = new logging.ConsoleLogger();
+
+describe(__filename, function () {
+  let db = null;
+  let mock = null;
+  const createDb = async (wrapperSettings = {}) => {
+    const settings = {};
+    db = new ueberdb.Database('mock', settings, {json: false, ...wrapperSettings}, logger);
+    mock = settings.mock;
+    mock.once('init', (cb) => cb());
+    await db.init();
+  };
+
+  afterEach(async function () {
+    if (mock != null) {
+      mock.removeAllListeners();
+      mock.once('close', (cb) => cb());
+      mock = null;
+    }
+    if (db != null) {
+      await db.close();
+      db = null;
+    }
+  });
+
+  it('flush() immediately after set() sees the write operation', async function () {
+    // Trigger a test timeout if flush() completes before the write operation is buffered.
+    await createDb({writeInterval: 1e9});
+    mock.on('set', (k, v, cb) => cb());
+    await Promise.all([
+      db.set('key', 'value'),
+      db.flush(),
+    ]);
+  });
+
+  it('flush() immediately after setSub() sees the write operation', async function () {
+    // Trigger a test timeout if flush() completes before the write operation is buffered.
+    await createDb({writeInterval: 1e9});
+    mock.on('get', (k, cb) => cb(null, {sub: 'oldvalue'}));
+    mock.on('set', (k, v, cb) => cb(null));
+    await Promise.all([
+      db.setSub('key', ['sub'], 'newvalue'),
+      db.flush(),
+    ]);
+  });
+
+  it('flush() immediately after remove() sees the write operation', async function () {
+    // Trigger a test timeout if flush() completes before the write operation is buffered.
+    await createDb({writeInterval: 1e9});
+    mock.on('remove', (k, cb) => cb(null));
+    await Promise.all([
+      db.remove('key'),
+      db.flush(),
+    ]);
+  });
+});

package/test/test_metrics.js

@@ -2,7 +2,6 @@
 
 const assert = require('assert').strict;
 const ueberdb = require('../index');
-const util = require('util');
 
 // Gate is a normal Promise that resolves when its open() method is called.
 class Gate extends Promise {
@@ -43,11 +42,8 @@ describe(__filename, function () {
 
   before(async function () {
     const settings = {};
-    const udb = new ueberdb.Database('mock', settings);
+    db = new ueberdb.Database('mock', settings);
     mock = settings.mock;
-    db = {metrics: udb.metrics};
-    const fns = ['init', 'close', 'get', 'getSub', 'findKeys', 'flush', 'remove', 'set', 'setSub'];
-    for (const fn of fns) db[fn] = util.promisify(udb[fn].bind(udb));
     mock.once('init', (cb) => cb());
     await db.init();
   });

package/test/test_postgres.js

@@ -3,15 +3,14 @@
 const assert = require('assert').strict;
 const {databases} = require('./lib/databases');
 const ueberdb = require('../index');
-const util = require('util');
 
 describe(__filename, function () {
   it('connection string instead of settings object', async function () {
     const {user, password, host, database} = databases.postgres;
     const db =
         new ueberdb.Database('postgres', `postgres://${user}:${password}@${host}/${database}`);
-    await util.promisify(db.init.bind(db))();
-    await util.promisify(db.set.bind(db))('key', 'val');
-    assert.equal(await util.promisify(db.get.bind(db))('key'), 'val');
+    await db.init();
+    await db.set('key', 'val');
+    assert.equal(await db.get('key'), 'val');
   });
 });

package/test/test_setSub.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const assert = require('assert').strict;
+const ueberdb = require('../index');
+
+describe(__filename, function () {
+  it('setSub rejects __proto__', async function () {
+    const db = new ueberdb.Database('memory', {}, {});
+    await db.init();
+    await db.set('k', {});
+    await assert.rejects(db.setSub('k', ['__proto__'], 'v'));
+  });
+});

package/test/test_tojson.js

@@ -2,15 +2,12 @@
 
 const assert = require('assert').strict;
 const ueberdb = require('../index');
-const util = require('util');
 
 describe(__filename, function () {
   let db = null;
 
   before(async function () {
-    const udb = new ueberdb.Database('memory', {}, {});
-    db = {};
-    for (const fn of ['init', 'close', 'set', 'get']) db[fn] = util.promisify(udb[fn].bind(udb));
+    db = new ueberdb.Database('memory', {}, {});
     await db.init();
   });