hypercore 10.0.0-alpha.1 → 10.0.0-alpha.13

package/test/replicate.js

@@ -294,3 +294,79 @@ test('multiplexing multiple times over the same stream', async function (t) {
   t.is(b1.length, a1.length, 'same length')
   t.end()
 })
+
+test('destroying a stream and re-replicating works', async function (t) {
+  const core = await create()
+
+  while (core.length < 33) await core.append(Buffer.from('#' + core.length))
+
+  const clone = await create(core.key)
+
+  let s1 = core.replicate(true)
+  let s2 = clone.replicate(false)
+
+  s1.pipe(s2).pipe(s1)
+
+  await s2.opened
+
+  const all = []
+  for (let i = 0; i < 33; i++) {
+    all.push(clone.get(i))
+  }
+
+  clone.once('download', function () {
+    // simulate stream failure in the middle of bulk downloading
+    s1.destroy()
+  })
+
+  await new Promise((resolve) => s1.once('close', resolve))
+
+  // retry
+  s1 = core.replicate(true)
+  s2 = clone.replicate(false)
+
+  s1.pipe(s2).pipe(s1)
+
+  const blocks = await Promise.all(all)
+
+  t.is(blocks.length, 33, 'downloaded 33 blocks')
+})
+
+test('replicate discrete range', async function (t) {
+  const a = await create()
+
+  await a.append(['a', 'b', 'c', 'd', 'e'])
+
+  const b = await create(a.key)
+
+  let d = 0
+  b.on('download', () => d++)
+
+  replicate(a, b, t)
+
+  const r = b.download({ blocks: [0, 2, 3] })
+  await r.downloaded()
+
+  t.is(d, 3)
+  t.alike(await b.get(0), Buffer.from('a'))
+  t.alike(await b.get(2), Buffer.from('c'))
+  t.alike(await b.get(3), Buffer.from('d'))
+})
+
+test('replicate discrete empty range', async function (t) {
+  const a = await create()
+
+  await a.append(['a', 'b', 'c', 'd', 'e'])
+
+  const b = await create(a.key)
+
+  let d = 0
+  b.on('download', () => d++)
+
+  replicate(a, b, t)
+
+  const r = b.download({ blocks: [] })
+  await r.downloaded()
+
+  t.is(d, 0)
+})

package/test/sessions.js

@@ -15,6 +15,7 @@ test('sessions - can create writable sessions from a read-only core', async func
   t.absent(core.writable)
 
   const session = core.session({ keyPair: { secretKey: keyPair.secretKey } })
+  await session.ready()
   t.ok(session.writable)
 
   try {
@@ -74,7 +75,8 @@ test('sessions - writable session with invalid keypair throws', async function (
 
   try {
     const core = new Hypercore(ram, keyPair2.publicKey) // Create a new core in read-only mode.
-    core.session({ keyPair: keyPair1 })
+    const session = core.session({ keyPair: keyPair1 })
+    await session.ready()
     t.fail('invalid keypair did not throw')
   } catch {
     t.pass('invalid keypair threw')
@@ -171,3 +173,11 @@ test('sessions - close with from option', async function (t) {
   t.absent(core1.closed)
   t.alike(await core1.get(0), Buffer.from('hello world'))
 })
+
+test('sessions - custom valueEncoding on session', async function (t) {
+  const core1 = new Hypercore(ram)
+  const core2 = core1.session({ valueEncoding: 'utf-8' })
+
+  await core1.append(Buffer.from('hello world'))
+  t.is(await core2.get(0), 'hello world')
+})

package/test/storage.js

@@ -0,0 +1,31 @@
+const test = require('brittle')
+const sodium = require('sodium-universal')
+const crypto = require('hypercore-crypto')
+const RAM = require('random-access-memory')
+const Hypercore = require('..')
+
+const keyPair = crypto.keyPair(Buffer.alloc(sodium.crypto_sign_SEEDBYTES, 'seed'))
+
+const encryptionKey = Buffer.alloc(sodium.crypto_stream_KEYBYTES, 'encryption key')
+
+test('storage layout', async function (t) {
+  const core = new Hypercore(RAM, { keyPair })
+
+  for (let i = 0; i < 10000; i++) {
+    await core.append(Buffer.from([i]))
+  }
+
+  t.snapshot(core.core.blocks.storage.toBuffer().toString('base64'), 'blocks')
+  t.snapshot(core.core.tree.storage.toBuffer().toString('base64'), 'tree')
+})
+
+test('encrypted storage layout', async function (t) {
+  const core = new Hypercore(RAM, { keyPair, encryptionKey })
+
+  for (let i = 0; i < 10000; i++) {
+    await core.append(Buffer.from([i]))
+  }
+
+  t.snapshot(core.core.blocks.storage.toBuffer().toString('base64'), 'blocks')
+  t.snapshot(core.core.tree.storage.toBuffer().toString('base64'), 'tree')
+})

package/test/streams.js

@@ -0,0 +1,55 @@
+const test = require('brittle')
+
+const { create } = require('./helpers')
+
+test('basic read stream', async function (t) {
+  const core = await create()
+
+  const expected = [
+    'hello',
+    'world',
+    'verden',
+    'welt'
+  ]
+
+  await core.append(expected)
+
+  for await (const data of core.createReadStream()) {
+    t.alike(data.toString(), expected.shift())
+  }
+
+  t.is(expected.length, 0)
+})
+
+test('read stream with start / end', async function (t) {
+  const core = await create()
+
+  const datas = [
+    'hello',
+    'world',
+    'verden',
+    'welt'
+  ]
+
+  await core.append(datas)
+
+  {
+    const expected = datas.slice(1)
+
+    for await (const data of core.createReadStream({ start: 1 })) {
+      t.alike(data.toString(), expected.shift())
+    }
+
+    t.is(expected.length, 0)
+  }
+
+  {
+    const expected = datas.slice(2, 3)
+
+    for await (const data of core.createReadStream({ start: 2, end: 3 })) {
+      t.alike(data.toString(), expected.shift())
+    }
+
+    t.is(expected.length, 0)
+  }
+})