corestore 5.8.0 → 6.0.0-alpha.1

package/test/all.js

@@ -1,485 +1,156 @@
-const p = require('path')
-const ram = require('random-access-memory')
-const raf = require('random-access-file')
-const datEncoding = require('dat-encoding')
-const hypercoreCrypto = require('hypercore-crypto')
 const test = require('tape')
+const crypto = require('hypercore-crypto')
+const ram = require('random-access-memory')
+const tmp = require('tmp-promise')
 
 const Corestore = require('..')
-const {
-  runAll,
-  validateCore,
-  cleanup
-} = require('./helpers')
-
-test('ram-based corestore, different get options', async t => {
-  const store1 = await create(ram)
-  const core1 = store1.default()
-  var core2, core3, core4, core5, core6
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core1.append('hello', cb),
-    cb => {
-      // Buffer arg
-      core2 = store1.get(core1.key)
-      return core2.ready(cb)
-    },
-    cb => {
-      // Object arg
-      core3 = store1.get({ key: core1.key })
-      return core3.ready(cb)
-    },
-    cb => {
-      // Discovery key option
-      core4 = store1.get({ discoveryKey: core1.discoveryKey })
-      return core4.ready(cb)
-    },
-    cb => {
-      // String option
-      core5 = store1.get({ key: datEncoding.encode(core1.key) })
-      return core5.ready(cb)
-    },
-    cb => {
-      // Custom keypair option
-      core6 = store1.get({ keyPair: { secretKey: core1.secretKey, publicKey: core1.key } })
-      return core6.ready(cb)
-    }
-  ])
-
-  t.same(core1, core2)
-  t.same(core1, core3)
-  t.same(core1, core4)
-  t.same(core1, core5)
-  t.same(core1, core6)
-  t.end()
-})
 
-test('ram-based corestore, simple replication', async t => {
-  const store1 = await create(ram)
-  const store2 = await create(ram)
-  const core1 = store1.default()
-  const core2 = store1.get()
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core2.ready(cb),
-    cb => {
-      core3 = store2.default(core1.key)
-      return core3.ready(cb)
-    },
-    cb => {
-      core4 = store2.get({ key: core2.key })
-      return core4.ready(cb)
-    },
-    cb => core1.append('hello', cb),
-    cb => core1.append('world', cb),
-    cb => core2.append('cat', cb),
-    cb => core2.append('dog', cb),
-    cb => {
-      const stream = store1.replicate(true)
-      stream.pipe(store2.replicate(false)).pipe(stream)
-      stream.on('end', cb)
-    }
-  ])
-
-  await validateCore(t, core3, [Buffer.from('hello'), Buffer.from('world')])
-  await validateCore(t, core4, [Buffer.from('cat'), Buffer.from('dog')])
+test('basic get with caching', async function (t) {
+  const store = new Corestore(ram)
+  const core1a = store.get({ name: 'core-1' })
+  const core1b = store.get({ name: 'core-1' })
+  const core2 = store.get({ name: 'core-2' })
 
-  t.end()
-})
+  await Promise.all([core1a.ready(), core1b.ready(), core2.ready()])
 
-test('ram-based corestore, replicating with different default keys', async t => {
-  const store1 = await create(ram)
-  const store2 = await create(ram)
-  const core1 = store1.default()
-  const core2 = store1.get()
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core2.ready(cb),
-    cb => {
-      core3 = store2.default()
-      return core3.ready(cb)
-    },
-    cb => {
-      core4 = store2.get({ key: core1.key })
-      return core4.ready(cb)
-    },
-    cb => core1.append('cat', cb),
-    cb => core1.append('dog', cb),
-    cb => {
-      const stream = store1.replicate(true)
-      stream.pipe(store2.replicate(false)).pipe(stream)
-      stream.on('end', cb)
-    }
-  ])
-
-  await validateCore(t, core4, [Buffer.from('cat'), Buffer.from('dog')])
-  t.end()
-})
+  t.same(core1a.key, core1b.key)
+  t.notSame(core1a.key, core2.key)
 
-test('ram-based corestore, sparse replication', async t => {
-  const store1 = await create(ram, { sparse: true })
-  const store2 = await create(ram, { sparse: true })
-  const core1 = store1.default()
-  const core2 = store1.get()
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core2.ready(cb),
-    cb => {
-      t.same(core2.sparse, true)
-      t.same(core1.sparse, true)
-      return process.nextTick(cb, null)
-    },
-    cb => {
-      core3 = store2.default(core1.key)
-      return core3.ready(cb)
-    },
-    cb => {
-      core4 = store2.get({ key: core2.key })
-      return core4.ready(cb)
-    },
-    cb => {
-      const stream = store1.replicate(true, { live: true })
-      stream.pipe(store2.replicate(false, { live: true })).pipe(stream)
-      return process.nextTick(cb, null)
-    },
-    cb => core1.append('hello', cb),
-    cb => core1.append('world', cb),
-    cb => core2.append('cat', cb),
-    cb => core2.append('dog', cb),
-    cb => {
-      t.same(core3.length, 0)
-      t.same(core4.length, 0)
-      return process.nextTick(cb, null)
-    }
-  ])
-
-  await validateCore(t, core3, [Buffer.from('hello'), Buffer.from('world')])
-  await validateCore(t, core4, [Buffer.from('cat'), Buffer.from('dog')])
-  t.end()
-})
+  t.true(core1a.writable)
+  t.true(core1b.writable)
 
-test('ram-based corestore, sparse replication with different default keys', async t => {
-  const store1 = await create(ram, { sparse: true })
-  const store2 = await create(ram, { sparse: true })
-  const core1 = store1.default()
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => {
-      core3 = store2.default()
-      return core3.ready(cb)
-    },
-    cb => {
-      const s1 = store1.replicate(true, { live: true })
-      const s2 = store2.replicate(false, { live: true })
-      s1.pipe(s2).pipe(s1)
-      return process.nextTick(cb, null)
-    },
-    cb => core1.append('cat', cb),
-    cb => core1.append('dog', cb),
-    cb => {
-      core4 = store2.get({ key: core1.key })
-      return core4.ready(cb)
-    },
-    cb => {
-      t.same(core4.length, 0)
-      t.same(core1.length, 2)
-      return process.nextTick(cb, null)
-    }
-  ])
-
-  await validateCore(t, core4, [Buffer.from('cat'), Buffer.from('dog')])
-  t.end()
-})
+  t.same(store.cores.size, 2)
 
-test('raf-based corestore, simple replication', async t => {
-  const store1 = await create(path => raf(p.join('store1', path)))
-  const store2 = await create(path => raf(p.join('store2', path)))
-  const core1 = store1.default()
-  const core2 = store1.get()
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core2.ready(cb),
-    cb => {
-      core3 = store2.default({ key: core1.key })
-      return core3.ready(cb)
-    },
-    cb => {
-      core4 = store2.get({ key: core2.key })
-      return core4.ready(cb)
-    },
-    cb => core1.append('hello', cb),
-    cb => core1.append('world', cb),
-    cb => core2.append('cat', cb),
-    cb => core2.append('dog', cb),
-    cb => {
-      setImmediate(() => {
-        const stream = store1.replicate(true)
-        stream.pipe(store2.replicate(false)).pipe(stream)
-        stream.on('end', cb)
-      })
-    }
-  ])
-
-  await validateCore(t, core3, [Buffer.from('hello'), Buffer.from('world')])
-  await validateCore(t, core4, [Buffer.from('cat'), Buffer.from('dog')])
-  await cleanup(['store1', 'store2'])
   t.end()
 })
 
-test('raf-based corestore, close and reopen', async t => {
-  var store = await create('test-store')
-  var firstCore = store.default()
-  var reopenedCore = null
-
-  await runAll([
-    cb => firstCore.ready(cb),
-    cb => firstCore.append('hello', cb),
-    cb => store.close(cb),
-    cb => {
-      t.true(firstCore.closed)
-      return process.nextTick(cb, null)
-    },
-    cb => {
-      create('test-store').then(store => {
-        reopenedCore = store.default()
-        return reopenedCore.ready(cb)
-      })
-    }
-  ])
-
-  await validateCore(t, reopenedCore, [Buffer.from('hello')])
-  await cleanup(['test-store'])
-  t.end()
-})
+test('basic get with custom keypair', async function (t) {
+  const store = new Corestore(ram)
+  const kp1 = crypto.keyPair()
+  const kp2 = crypto.keyPair()
 
-test('raf-based corestore, close and reopen with keypair option', async t => {
-  var store = await create('test-store')
-  const keyPair = hypercoreCrypto.keyPair()
-  var firstCore = store.get({ keyPair })
-  var reopenedCore = null
-
-  await runAll([
-    cb => firstCore.ready(cb),
-    cb => firstCore.append('hello', cb),
-    cb => store.close(cb),
-    cb => {
-      t.true(firstCore.closed)
-      return process.nextTick(cb, null)
-    },
-    cb => {
-      create('test-store').then(store => {
-        reopenedCore = store.get({ key: keyPair.publicKey })
-        return reopenedCore.ready(cb)
-      })
-    }
-  ])
-
-  await validateCore(t, reopenedCore, [Buffer.from('hello')])
-  t.true(reopenedCore.writable)
-
-  await cleanup(['test-store'])
-  t.end()
-})
+  const core1 = store.get(kp1)
+  const core2 = store.get(kp2)
+  await Promise.all([core1.ready(), core2.ready()])
+
+  t.same(core1.key, kp1.publicKey)
+  t.same(core2.key, kp2.publicKey)
+  t.true(core1.writable)
+  t.true(core2.writable)
 
-test('live replication with an additional core', async t => {
-  const store1 = await create(ram)
-  const store2 = await create(ram)
-
-  const core1 = store1.default()
-  var core2 = null
-  var core3 = null
-  var core4 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => {
-      core3 = store2.default({ key: core1.key })
-      return core3.ready(cb)
-    },
-    cb => {
-      const stream = store1.replicate(true, { live: true })
-      stream.pipe(store2.replicate(false, { live: true })).pipe(stream)
-      return cb(null)
-    },
-    cb => {
-      core2 = store1.get()
-      return core2.ready(cb)
-    },
-    cb => {
-      core4 = store2.get(core2.key)
-      return core4.ready(cb)
-    },
-    cb => core2.append('hello', cb),
-    cb => core2.append('world', cb)
-  ])
-
-  await validateCore(t, core4, [Buffer.from('hello'), Buffer.from('world')])
   t.end()
 })
 
-test('namespaced corestores use separate default keys', async t => {
-  const store1 = await create(ram)
-  const store2 = store1.namespace('store2')
-  const store3 = store1.namespace('store3')
-
-  await store2.ready()
-  await store3.ready()
+test('basic namespaces', async function (t) {
+  const store = new Corestore(ram)
+  const ns1 = store.namespace('ns1')
+  const ns2 = store.namespace('ns2')
+  const ns3 = store.namespace('ns1') // Duplicate namespace
 
-  const feed1 = store2.default()
-  const feed2 = store3.default()
+  const core1 = ns1.get({ name: 'main' })
+  const core2 = ns2.get({ name: 'main' })
+  const core3 = ns3.get({ name: 'main' })
+  await Promise.all([core1.ready(), core2.ready(), core3.ready()])
 
-  t.true(!feed1.key.equals(feed2.key))
+  t.false(core1.key.equals(core2.key))
+  t.true(core1.key.equals(core3.key))
+  t.true(core1.writable)
+  t.true(core2.writable)
+  t.true(core3.writable)
+  t.same(store.cores.size, 2)
 
   t.end()
 })
 
-test('namespaced corestores will not increment reference multiple times', async t => {
-  const store1 = await create(ram)
-  const store2 = store1.namespace('store2')
-  const store3 = store1.namespace('store3')
+test('basic replication', async function (t) {
+  const store1 = new Corestore(ram)
+  const store2 = new Corestore(ram)
 
-  await store2.ready()
-  await store3.ready()
+  const core1 = store1.get({ name: 'core-1' })
+  const core2 = store1.get({ name: 'core-2' })
+  await core1.append('hello')
+  await core2.append('world')
 
-  const feed1 = store2.default()
-  await feed1.ready()
-  const feed3 = store3.get({ key: feed1.key })
-  const feed4 = store3.get({ key: feed1.key })
-  const feed5 = store3.get({ key: feed1.key })
+  const core3 = store2.get({ key: core1.key })
+  const core4 = store2.get({ key: core2.key })
 
-  t.same(feed1, feed3)
-  t.same(feed1, feed4)
-  t.same(feed1, feed5)
+  const s = store1.replicate(true)
+  s.pipe(store2.replicate(false)).pipe(s)
 
-  const entry = store1.cache.entry(feed1.discoveryKey.toString('hex'))
-  t.same(entry.refs, 2)
+  t.same(await core3.get(0), Buffer.from('hello'))
+  t.same(await core4.get(0), Buffer.from('world'))
 
   t.end()
 })
 
-test('namespaced corestores can be nested', async t => {
-  const store1 = await create(ram)
-  const store2 = store1.namespace('store2')
-  const store1a = store1.namespace('a')
-  const store2a = store2.namespace('a')
+test('nested namespaces', async function (t) {
+  const store = new Corestore(ram)
+  const ns1a = store.namespace('ns1').namespace('a')
+  const ns1b = store.namespace('ns1').namespace('b')
 
-  const feed1 = store1.default()
-  const feed2 = store2.default()
-  const feed1a = store1a.default()
-  const feed2a = store2a.default()
+  const core1 = ns1a.get({ name: 'main' })
+  const core2 = ns1b.get({ name: 'main' })
+  await Promise.all([core1.ready(), core2.ready()])
 
-  await feed1.ready()
-  await feed2.ready()
-  await feed1a.ready()
-  await feed2a.ready()
-
-  t.notEqual(feed1a.key, feed2a.key)
+  t.false(core1.key.equals(core2.key))
+  t.true(core1.writable)
+  t.true(core2.writable)
+  t.same(store.cores.size, 2)
 
   t.end()
 })
 
-test('caching works correctly when reopening by discovery key', async t => {
-  var store = await create('test-store')
-  var firstCore = store.default()
-  var discoveryKey = null
-  var reopenedCore = null
-
-  await runAll([
-    cb => firstCore.ready(cb),
-    cb => {
-      discoveryKey = firstCore.discoveryKey
-      return cb(null)
-    },
-    cb => firstCore.append('hello', cb),
-    cb => store.close(cb),
-    cb => {
-      t.true(firstCore.closed)
-      return process.nextTick(cb, null)
-    },
-    cb => {
-      create('test-store').then(reopenedStore => {
-        store = reopenedStore
-        reopenedCore = store.get({ discoveryKey })
-        return reopenedCore.ready(cb)
-      })
-    },
-    cb => {
-      const idx = discoveryKey.toString('hex')
-      t.true(store.cache.has(idx))
-      return cb(null)
-    }
-  ])
-
-  await validateCore(t, reopenedCore, [Buffer.from('hello')])
-  await cleanup(['test-store'])
+test('core uncached when all sessions close', async function (t) {
+  const store = new Corestore(ram)
+  const core1 = store.get({ name: 'main' })
+  await core1.ready()
+  t.same(store.cores.size, 1)
+  await core1.close()
+  t.same(store.cores.size, 0)
   t.end()
 })
 
-test('can check if cores are loaded', async t => {
-  const store = await create(ram)
-  await store.ready()
+test('writable core loaded from name userData', async function (t) {
+  const dir = await tmp.dir({ unsafeCleanup: true })
+
+  let store = new Corestore(dir.path)
+  let core = store.get({ name: 'main' })
+  await core.ready()
+  const key = core.key
+
+  t.true(core.writable)
+  await core.append('hello')
+  t.same(core.length, 1)
 
-  const feed1 = store.default()
-  const feed2 = store.get()
-  const badKey = hypercoreCrypto.randomBytes(32)
-  const badDiscoveryKey = hypercoreCrypto.discoveryKey(badKey)
+  await store.close()
+  store = new Corestore(dir.path)
+  core = store.get(key)
+  await core.ready()
 
-  t.true(store.isLoaded({ key: feed1.key }))
-  t.true(store.isLoaded({ discoveryKey: feed1.discoveryKey }))
-  t.true(store.isLoaded({ discoveryKey: feed2.discoveryKey }))
-  t.false(store.isLoaded({ key: badKey }))
-  t.false(store.isLoaded({ key: badDiscoveryKey }))
+  t.true(core.writable)
+  await core.append('world')
+  t.same(core.length, 2)
+  t.same(await core.get(0), Buffer.from('hello'))
+  t.same(await core.get(1), Buffer.from('world'))
 
+  await dir.cleanup()
   t.end()
 })
 
-test('top-level corestore replicates all opened cores', async t => {
-  const store1 = await create(ram)
-  const store2 = await create(ram)
-
-  const core1 = store1.default()
-  const ns1 = store1.namespace()
-  var core2 = ns1.default()
-  var core3 = null
-
-  await runAll([
-    cb => core1.ready(cb),
-    cb => core2.ready(cb),
-    cb => {
-      // Only replicate the top-level corestore
-      const stream = store1.replicate(true, { live: true })
-      stream.pipe(store2.replicate(false, { live: true })).pipe(stream)
-      return cb(null)
-    },
-    cb => {
-      core3 = store2.get(core2.key)
-      return core3.ready(cb)
-    },
-    cb => core2.append('hello', cb),
-    cb => core2.append('world', cb)
-  ])
-
-  await validateCore(t, core3, [Buffer.from('hello'), Buffer.from('world')])
+test('storage locking', async function (t) {
+  const dir = await tmp.dir({ unsafeCleanup: true })
+
+  const store1 = new Corestore(dir.path)
+  const store2 = new Corestore(dir.path)
+  await store1.ready()
+
+  try {
+    await store2.ready()
+    t.fail('dir should have been locked')
+  } catch {
+    t.pass('dir was locked')
+  }
+
+  await dir.cleanup()
   t.end()
 })
-async function create (storage, opts) {
-  const store = new Corestore(storage, opts)
-  await store.ready()
-  return store
-}

package/test/helpers/index.js

@@ -1,37 +1,7 @@
-const rimraf = require('rimraf')
-
-function runAll (ops) {
-  return new Promise((resolve, reject) => {
-    runNext(ops.shift())
-    function runNext (op) {
-      op(err => {
-        if (err) return reject(err)
-        const next = ops.shift()
-        if (!next) return resolve()
-        return runNext(next)
-      })
-    }
-  })
-}
-
-function validateCore (t, core, values) {
-  const ops = values.map((v, idx) => cb => {
-    core.get(idx, (err, value) => {
-      t.error(err, 'no error')
-      t.same(value, values[idx])
-      return cb(null)
-    })
-  })
-  return runAll(ops)
-}
+const fs = require('fs').promises
 
 async function cleanup (dirs) {
-  return Promise.all(dirs.map(dir => new Promise((resolve, reject) => {
-    rimraf(dir, err => {
-      if (err) return reject(err)
-      return resolve()
-    })
-  })))
+  return Promise.allSettled(dirs.map(dir => fs.rmdir(dir, { recursive: true })))
 }
 
 function delay (ms, cb) {
@@ -45,7 +15,5 @@ function delay (ms, cb) {
 
 module.exports = {
   delay,
-  cleanup,
-  validateCore,
-  runAll
+  cleanup
 }