@live-change/db-store-localstorage 0.6.0

package/tests/broadcast-range-changes.js

@@ -0,0 +1,168 @@
+const test = require('tape')
+
+require('fake-indexeddb/auto.js')
+const idb = require('idb')
+const Store = require('../lib/Store.js')
+
+const nextTick = () => new Promise(resolve => {
+  console.log("WAIT!")
+  setTimeout(resolve, 100)
+})
+
+test("store broadcast range changes", t => {
+  t.plan(5)
+
+  let writeStore
+  let readStore
+
+  t.test("create stores", async t => {
+    t.plan(2)
+    readStore = new Store('test-broadcast-object-changes', 'test', 'local')
+    await readStore.open()
+    t.pass('read store created')
+    writeStore = new Store('test-broadcast-object-changes', 'test', 'local')
+    await writeStore.open()
+    t.pass('write store created')
+  })
+
+  t.test("put objects", async t => {
+    t.plan(1)
+    await writeStore.put({ v: 1, id: 'a' })
+    await writeStore.put({ v: 3, id: 'c' })
+    t.pass('objects written')
+  })
+
+  let nextValueResolve
+  let gotNextValue
+  const getNextValue = () => {
+    if(gotNextValue) {
+      gotNextValue = false
+      return rangeObservable.list
+    }
+    return new Promise((resolve, reject) => nextValueResolve = resolve)
+  }
+  let rangeObservable
+  const rangeObserver = (signal, value, ...rest) => {
+    console.log("SIGNAL", signal, value, ...rest)
+    if(nextValueResolve) {
+      nextValueResolve(rangeObservable.list)
+    } else {
+      gotNextValue = true
+    }
+  }
+
+  t.test("observe range [a,z]", t => {
+    t.plan(6)
+
+
+    let values
+
+    t.test("get values", async t => {
+      t.plan(1)
+      await nextTick()
+      rangeObservable = readStore.rangeObservable({ gte: 'a', lte: 'z' })
+      rangeObservable.observe(rangeObserver)
+      values = await getNextValue()
+      t.deepEqual(values, [{v: 1, id: 'a'}, {v: 3, id: 'c'}], 'range value')
+    })
+
+    t.test("remove object 'a' from observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.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.plan(1)
+      await nextTick()
+      await writeStore.put({ id: 'a', v: 4 })
+      let values = await getNextValue()
+      t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 3, id: 'c' } ], 'range value' )
+    })
+
+    t.test("add object 'b' to observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.put({ id: 'b', v: 5 })
+      let values = await getNextValue()
+      t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
+    })
+
+    t.test("add object 'd' to observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.put({ id: 'd', v: 6 })
+      let values = await getNextValue()
+      t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 5, id: 'b' }, { v: 3, id: 'c' }, { v: 6, id: 'd' } ], 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      await nextTick()
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("observe range (a,d)", t => {
+    t.plan(6)
+
+    let values
+
+    t.test("get values", async t => {
+      t.plan(1)
+      await nextTick()
+      rangeObservable = readStore.rangeObservable({ gt: 'a', lt: 'd' })
+      rangeObservable.observe(rangeObserver)
+      values = await getNextValue()
+      t.deepEqual(values, [{v: 5, id: 'b'}, {v: 3, id: 'c'}], 'range value')
+    })
+
+    t.test("remove object 'd' outside observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.delete('d')
+      t.pass('deleted')
+    })
+
+    t.test("remove object 'a' outside observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.delete('a')
+      t.pass('deleted')
+    })
+
+    t.test("add object 'ab' to observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.put({ id: 'ab', v: 7 })
+      let values = await getNextValue()
+      t.deepEqual(values, [ { v: 7, id: 'ab' }, { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
+    })
+
+    t.test("remove object 'ab' from observed range", async t => {
+      t.plan(1)
+      await nextTick()
+      await writeStore.delete('ab')
+      let values = await getNextValue()
+      t.deepEqual(values, [ { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      await nextTick()
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("close database", async t => {
+    await readStore.close()
+    await writeStore.close()
+    t.pass('closed')
+    t.end()
+  })
+
+})

package/tests/limited-range-observable.js

@@ -0,0 +1,176 @@
+const test = require('tape')
+
+require('fake-indexeddb/auto.js')
+const idb = require('idb')
+const Store = require('../lib/Store.js')
+
+test("store limited range observable", t => {
+  t.plan(5)
+
+  let store
+
+  t.test("create store", async t => {
+    t.plan(1)
+    store = new Store('test-limited-range-observable', 'test', 'local')
+    await store.open()
+    t.pass('store created')
+  })
+
+  let objects = []
+
+  t.test("put objects", async t => {
+    t.plan(1)
+    store.put({ id: 'a_0', v: 1  })
+    for(let i = 0; i < 10; i++) {
+      let obj = { id: 'b_' + i, v: i  }
+      objects.push(obj)
+      await store.put(obj)
+    }
+    await store.put({ id: 'c_0', v: 1  })
+    t.pass('objects written')
+  })
+
+  let nextValueResolve
+  let gotNextValue
+  const getNextValue = () => {
+    if(gotNextValue) {
+      gotNextValue = false
+      return rangeObservable.list
+    }
+    return new Promise((resolve, reject) => nextValueResolve = resolve)
+  }
+  let rangeObservable
+  const rangeObserver = (signal, value, ...rest) => {
+    console.log("SIGNAL", signal, value, ...rest)
+    gotNextValue = true
+    if(nextValueResolve) nextValueResolve(rangeObservable.list)
+  }
+
+  t.test("observe range [b_0,b_9]", t => {
+    t.plan(7)
+    rangeObservable = store.rangeObservable({ gte: 'b_0', lte: 'b_9', limit: 5 })
+    rangeObservable.observe(rangeObserver)
+
+    let values
+
+    t.test("get values", async t => {
+      t.plan(1)
+      values = await getNextValue()
+      t.deepEqual(values, objects.slice(0,5), 'range value')
+    })
+
+    t.test("remove object 'b_3' from observed range", async t => {
+      t.plan(1)
+      await store.delete('b_3')
+      objects.splice(3, 1)
+      await getNextValue() // one shorter
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_3' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_3', v: 10 }
+      await store.put(obj)
+      objects.splice(3, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_32' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_32', v: 11 }
+      await store.put(obj)
+      objects.splice(4, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_35' outside observed range limits", async t => {
+      t.plan(1)
+      const obj = { id: 'b_35', v: 11 }
+      await store.put(obj)
+      objects.splice(5, 0, obj)
+      t.pass('added')
+    })
+
+    t.test("delete object 'b_32' so b_35 will enter into range limits", async t => {
+      t.plan(1)
+      await store.delete('b_32')
+      objects.splice(4, 1)
+      await getNextValue()
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("observe range (b_0,b_5)", t => {
+    t.plan(7)
+    gotNextValue = false
+    rangeObservable = store.rangeObservable({ gt: 'b_0', lt: 'b_5', limit: 3 })
+    rangeObservable.observe(rangeObserver)
+
+    let values
+
+    t.test("get values", async t => {
+      t.plan(1)
+      values = await getNextValue()
+      t.deepEqual(values, objects.slice(1,4), 'range value')
+    })
+
+    t.test("remove object 'b_0' outside observed range", async t => {
+      t.plan(1)
+      await store.delete('b_0')
+      t.pass('deleted')
+    })
+
+    t.test("remove object 'b_5' outside observed range", async t => {
+      t.plan(1)
+      await store.delete('b_5')
+      t.pass('deleted')
+    })
+
+    t.test("remove object 'b_4' outside observed range limits", async t => {
+      t.plan(1)
+      await store.delete('b_4')
+      t.pass('deleted')
+    })
+
+    t.test("add object 'b_12' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_12', v: 7 }
+      await store.put(obj)
+      objects.splice(2, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(1,4), 'range value' )
+    })
+
+    t.test("remove object 'b_12' from observed range", async t => {
+      t.plan(1)
+      await store.delete('b_12')
+      objects.splice(2, 1)
+      await getNextValue()
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(1,4) , 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("close database", async t => {
+    await store.close()
+    t.pass('closed')
+    t.end()
+  })
+
+})

package/tests/limited-reverse-range-observable.js

@@ -0,0 +1,175 @@
+const test = require('tape')
+
+require('fake-indexeddb/auto.js')
+const idb = require('idb')
+const Store = require('../lib/Store.js')
+
+test("store limited reverse range observable", t => {
+  t.plan(5)
+
+  let store
+
+  t.test("create store", async t => {
+    t.plan(1)
+    store = new Store('test-limited-reverse-range-observable', 'test', 'local')
+    await store.open()
+    t.pass('store created')
+  })
+
+  let objects = []
+
+  t.test("put objects", async t => {
+    t.plan(1)
+    await store.put({ id: 'a_0', v: 1  })
+    for(let i = 0; i < 10; i++) {
+      let obj = { id: 'b_' + i, v: i  }
+      objects.unshift(obj)
+      await store.put(obj)
+    }
+    await store.put({ id: 'c_0', v: 1  })
+    t.pass('objects written')
+  })
+
+  let nextValueResolve
+  let gotNextValue
+  const getNextValue = () => {
+    if(gotNextValue) {
+      gotNextValue = false
+      return rangeObservable.list
+    }
+    return new Promise((resolve, reject) => nextValueResolve = resolve)
+  }
+  let rangeObservable
+  const rangeObserver = (signal, value, ...rest) => {
+    console.log("SIGNAL", signal, value, ...rest)
+    gotNextValue = true
+    if(nextValueResolve) nextValueResolve(rangeObservable.list)
+  }
+
+  t.test("observe reverse range [b_9,b_0]", t => {
+    t.plan(7)
+    rangeObservable = store.rangeObservable({ gte: 'b_0', lte: 'b_9', limit: 5, reverse: true })
+    rangeObservable.observe(rangeObserver)
+
+    let values
+
+    t.test("get values", async t => {
+      t.plan(1)
+      values = await getNextValue()
+      t.deepEqual(values, objects.slice(0,5), 'range value')
+    })
+
+    t.test("remove object 'b_6' from observed range", async t => {
+      t.plan(1)
+      await store.delete('b_6')
+      objects.splice(3, 1)
+      await getNextValue() // one shorter
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_6' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_6', v: 10 }
+      await store.put(obj)
+      objects.splice(3, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_58' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_58', v: 11 }
+      await store.put(obj)
+      objects.splice(4, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("add object 'b_52' outside observed range limits", async t => {
+      t.plan(1)
+      const obj = { id: 'b_52', v: 11 }
+      await store.put(obj)
+      objects.splice(5, 0, obj)
+      t.pass('added')
+    })
+
+    t.test("delete object 'b_58' so b_52 will enter into range limits", async t => {
+      t.plan(1)
+      await store.delete('b_58')
+      objects.splice(4, 1)
+      await getNextValue()
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(0, 5), 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("observe reverse range (b_5,b_0)", t => {
+    t.plan(7)
+    gotNextValue = false
+    rangeObservable = store.rangeObservable({ gt: 'b_0', lt: 'b_5', limit: 3, reverse: true })
+    rangeObservable.observe(rangeObserver)
+
+    let values
+    t.test("get values", async t => {
+      t.plan(1)
+      values = await getNextValue()
+      t.deepEqual(values, objects.slice(6,9), 'range value')
+    })
+
+    t.test("remove object 'b_5' outside observed range", async t => {
+      t.plan(1)
+      await store.delete('b_5')
+      t.pass('deleted')
+    })
+
+    t.test("remove object 'b_0' outside observed range", async t => {
+      t.plan(1)
+      await store.delete('b_0')
+      t.pass('deleted')
+    })
+
+    t.test("remove object 'b_1' outside observed range limits", async t => {
+      t.plan(1)
+      await store.delete('b_1')
+      t.pass('deleted')
+    })
+
+    t.test("add object 'b_48' to observed range", async t => {
+      t.plan(1)
+      const obj = { id: 'b_48', v: 7 }
+      await store.put(obj)
+      objects.splice(6, 0, obj)
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(6,9), 'range value' )
+    })
+
+    t.test("remove object 'b_48' from observed range", async t => {
+      t.plan(1)
+      await store.delete('b_48')
+      objects.splice(6, 1)
+      await getNextValue()
+      let values = await getNextValue()
+      t.deepEqual(values, objects.slice(6,9) , 'range value' )
+    })
+
+    t.test("unobserve range", async t => {
+      t.plan(1)
+      rangeObservable.unobserve(rangeObserver)
+      t.pass('unobserved')
+    })
+  })
+
+  t.test("close database", async t => {
+    await store.close()
+    t.pass('closed')
+    t.end()
+  })
+
+})

package/tests/object-observable.js

@@ -0,0 +1,68 @@
+const test = require('tape')
+
+require('fake-indexeddb/auto.js')
+const idb = require('idb')
+const Store = require('../lib/Store.js')
+
+test("store object observable", t => {
+  t.plan(3)
+
+  let store
+
+  t.test("create store", async t => {
+    t.plan(1)
+    store = new Store('test-object-observable', 'test', 'local')
+    await store.open()
+    t.pass('store created')
+  })
+
+  let nextValueResolve
+  let gotNextValue
+  const getNextValue = () => {
+    if(gotNextValue) {
+      gotNextValue = false
+      return objectObservable.value
+    }
+    return new Promise((resolve, reject) => nextValueResolve = resolve)
+  }
+
+  let objectObservable
+  const objectObserver = (signal, value, ...rest) => {
+    console.log("SIGNAL", signal, value, ...rest)
+    gotNextValue = true
+    if(nextValueResolve) nextValueResolve(value)
+  }
+
+  t.test('observe object A', t => {
+    t.plan(3)
+    objectObservable = store.objectObservable('A')
+    objectObservable.observe(objectObserver)
+
+    t.test('get value', async t => {
+      t.plan(1)
+      let value = await getNextValue()
+      t.deepEqual(value, null, 'found null')
+    })
+
+    t.test("add object A", async t => {
+      t.plan(1)
+      await store.put({ id: 'A', a: 1 })
+      let value = await getNextValue()
+      t.deepEqual(value, { id: 'A', a: 1 } , 'found object' )
+    })
+
+    t.test("delete object A", async t => {
+      t.plan(1)
+      await store.delete('A')
+      let value = await getNextValue()
+      t.deepEqual(value, null , 'found null' )
+    })
+  })
+
+  t.test("close database", async t => {
+    await store.close()
+    t.pass('closed')
+    t.end()
+  })
+
+})