@live-change/db-store-level 0.6.22 → 0.7.0

package/tests/reverse-range-observable.js

@@ -1,10 +1,18 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
-
-const Store = require('../lib/Store.js')
+import test from 'tape'
+import levelup from 'levelup'
+import leveldown from 'leveldown'
+import encoding from 'encoding-down'
+import { rimraf } from 'rimraf'
+
+import Store from '../lib/Store.js'
+
+import PQueue from 'p-queue'
+const testQueue = new PQueue({ concurrency: 1 })
+function queued(fn) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
 
 const dbPath = `./test.rro.db`
 rimraf.sync(dbPath)
@@ -51,39 +59,40 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 1, id: 'a' } ], 'range value' )
 
-    t.test("remove object 'a' from observed range", async t => {
+    t.test("remove object 'a' from observed range", queued(async t => {
       t.plan(1)
       await store.delete('a')
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'a' to observed range", async t => {
+    t.test("add object 'a' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'a', v: 4 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 4, id: 'a' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'b' to observed range", async t => {
+    t.test("add object 'b' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'b', v: 5 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 5, id: 'b' }, { v: 4, id: 'a' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'd' to observed range", async t => {
+    t.test("add object 'd' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'd', v: 6 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 6, id: 'd' }, { v: 3, id: 'c' }, { v: 5, id: 'b' }, { v: 4, id: 'a' } ], 'range value' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
+
   })
 
   t.test("observe reverse range (d, a)", async t => {
@@ -93,45 +102,43 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 5, id: 'b' } ], 'range value' )
 
-    t.test("remove object 'd' outside observed range", async t => {
+    t.test("remove object 'd' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('d')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'a' outside observed range", async t => {
+    t.test("remove object 'a' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('a')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("add object 'ab' to observed range", async t => {
+    t.test("add object 'ab' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'ab', v: 7 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 5, id: 'b' }, { v: 7, id: 'ab' } ], 'range value' )
-    })
+    }))
 
-    t.test("remove object 'ab' from observed range", async t => {
+    t.test("remove object 'ab' from observed range", queued(async t => {
       t.plan(1)
       await store.delete('ab')
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 5, id: 'b' } ], 'range value' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
   })
 
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })

package/tests/store-non-reactive.js

@@ -1,10 +1,18 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
-
-const Store = require('../lib/Store.js')
+import test from 'tape'
+import levelup from 'levelup'
+import leveldown from 'leveldown'
+import encoding from 'encoding-down'
+import { rimraf } from 'rimraf'
+
+import Store from '../lib/Store.js'
+
+import PQueue from 'p-queue'
+const testQueue = new PQueue({ concurrency: 1 })
+function queued(fn) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
 
 const dbPath = `./test.nr.db`
 rimraf.sync(dbPath)
@@ -24,105 +32,102 @@ test("store non-reactive properties", t => {
   t.test("non reactive operations", async t => {
     t.plan(15)
 
-    t.test("put value", async t => {
+    t.test("put value", queued(async t => {
       t.plan(1)
       await store.put({ id:'a', v: 1 })
       t.pass('value written')
-    })
+    }))
 
-    t.test("get value", async t => {
+    t.test("get value", queued(async t => {
       t.plan(1)
       const v = await store.objectGet('a')
       t.deepEqual(v, { v: 1, id: 'a' }, 'value read')
-    })
-
+    }))
 
-    t.test("put another values", async t => {
+    t.test("put another values", queued(async t => {
       t.plan(1)
       await store.put({ id: 'c', v: 3 })
       await store.put({ id: 'b', v: 2 })
       t.pass('values written')
-    })
+    }))
 
-    t.test("get range [a,c]", async t => {
+    t.test("get range [a,c]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c' })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 2, id: 'b' }, { v: 3, id: 'c' } ], 'range read' )
-    })
+    }))
 
-    t.test("get reverse range [c,a]", async t => {
+    t.test("get reverse range [c,a]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', reverse: true })
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 2, id: 'b' },  { v: 1, id: 'a' } ], 'range read' )
-    })
+    }))
 
-    t.test("get range [a,c] with limit 2", async t => {
+    t.test("get range [a,c] with limit 2", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', limit: 2 })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 2, id: 'b' } ], 'range read' )
-    })
+    }))
 
-    t.test("get reverse range [c,a] with limit 2", async t => {
+    t.test("get reverse range [c,a] with limit 2", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', reverse: true, limit: 2 })
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 2, id: 'b' } ], 'range read' )
-    })
+    }))
 
-    t.test("get range (a,c]", async t => {
+    t.test("get range (a,c]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gt: 'a', lte: 'c' })
       t.deepEqual(values, [ { v: 2, id: 'b' }, { v: 3, id: 'c' } ], 'range read' )
-    })
+    }))
 
-    t.test("get reverse range [c,a)", async t => {
+    t.test("get reverse range [c,a)", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gt: 'a', lte: 'c', reverse: true })
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 2, id: 'b' }, ], 'range read' )
-    })
+    }))
 
-    t.test("get range [a,c)", async t => {
+    t.test("get range [a,c)", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lt: 'c' })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 2, id: 'b' } ], 'range read' )
-    })
+    }))
 
-    t.test("get reverse range (c,a]", async t => {
+    t.test("get reverse range (c,a]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lt: 'c', reverse: true })
       t.deepEqual(values, [ { v: 2, id: 'b' }, { v: 1, id: 'a' } ], 'range read' )
-    })
+    }))
 
-    t.test("get range (a,c)", async t => {
+    t.test("get range (a,c)", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gt: 'a', lt: 'c' })
       t.deepEqual(values, [ { v: 2, id: 'b' } ], 'range read' )
-    })
+    }))
 
-    t.test("get reverse range (a,c)", async t => {
+    t.test("get reverse range (a,c)", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gt: 'a', lt: 'c', reverse: true })
       t.deepEqual(values, [ { v: 2, id: 'b' } ], 'range read' )
-    })
+    }))
 
-    t.test("remove 'b'", async t => {
+    t.test("remove 'b'", queued(async t => {
       t.plan(1)
       await store.delete('b')
       t.pass("removed")
-    })
+    }))
 
-    t.test("get range [a,c]", async t => {
+    t.test("get range [a,c]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c' })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 3, id: 'c' } ], 'range read' )
-    })
+    }))
   })
 
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })