@ipld/car 4.1.6 → 5.0.1

package/cjs/browser-test/test-reader.js

@@ -1,278 +0,0 @@
-'use strict';
-
-var readerBrowser = require('../lib/reader-browser.js');
-var writerBrowser = require('../lib/writer-browser.js');
-var decoder = require('../lib/decoder.js');
-var Block = require('multiformats/block');
-var sha2 = require('multiformats/hashes/sha2');
-var raw = require('multiformats/codecs/raw');
-var base64 = require('multiformats/bases/base64');
-var dagPb = require('@ipld/dag-pb');
-var common = require('./common.js');
-var verifyStoreReader = require('./verify-store-reader.js');
-var fixtures = require('./fixtures.js');
-var fixturesExpectations = require('./fixtures-expectations.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var Block__namespace = /*#__PURE__*/_interopNamespace(Block);
-var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
-var dagPb__namespace = /*#__PURE__*/_interopNamespace(dagPb);
-
-describe('CarReader fromBytes()', () => {
-  it('complete', async () => {
-    const reader = await readerBrowser.CarReader.fromBytes(common.carBytes);
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-    common.assert.strictEqual(reader.version, 1);
-  });
-  it('complete (get before has) switch', async () => {
-    const reader = await readerBrowser.CarReader.fromBytes(common.carBytes);
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-  });
-  it('bad argument', async () => {
-    for (const arg of [
-        true,
-        false,
-        null,
-        undefined,
-        'string',
-        100,
-        { obj: 'nope' }
-      ]) {
-      await common.assert.isRejected(readerBrowser.CarReader.fromBytes(arg));
-    }
-  });
-  it('decode error - truncated', async () => {
-    await common.assert.isRejected(readerBrowser.CarReader.fromBytes(common.carBytes.slice(0, common.carBytes.length - 10)), {
-      name: 'Error',
-      message: 'Unexpected end of data'
-    });
-  });
-  it('v2 complete', async () => {
-    const reader = await readerBrowser.CarReader.fromBytes(common.goCarV2Bytes);
-    const roots = await reader.getRoots();
-    common.assert.strictEqual(roots.length, 1);
-    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
-    common.assert.strictEqual(reader.version, 2);
-    for (const {cid} of common.goCarV2Index) {
-      const block = await reader.get(cid);
-      common.assert.isDefined(block);
-      if (block) {
-        common.assert.ok(cid.equals(block.cid));
-        let content;
-        if (cid.code === dagPb__namespace.code) {
-          content = dagPb__namespace.decode(block.bytes);
-        } else if (cid.code === 85) {
-          content = new TextDecoder().decode(block.bytes);
-        } else {
-          common.assert.fail('Unexpected codec');
-        }
-        common.assert.deepStrictEqual(content, common.goCarV2Contents[cid.toString()]);
-      }
-    }
-  });
-  it('decode error - trailing null bytes', async () => {
-    const bytes = new Uint8Array(common.carBytes.length + 5);
-    bytes.set(common.carBytes);
-    try {
-      await readerBrowser.CarReader.fromBytes(bytes);
-    } catch (err) {
-      common.assert.strictEqual(err.message, 'Invalid CAR section (zero length)');
-      return;
-    }
-    common.assert.fail('Did not throw');
-  });
-  it('decode error - bad first byte', async () => {
-    const bytes = new Uint8Array(common.carBytes.length + 5);
-    bytes.set(common.carBytes);
-    bytes[0] = 0;
-    try {
-      await readerBrowser.CarReader.fromBytes(bytes);
-    } catch (err) {
-      common.assert.strictEqual(err.message, 'Invalid CAR header (zero length)');
-      return;
-    }
-    common.assert.fail('Did not throw');
-  });
-});
-describe('CarReader fromIterable()', () => {
-  it('complete (single chunk)', async () => {
-    const reader = await readerBrowser.CarReader.fromIterable(common.makeIterable(common.carBytes, common.carBytes.length));
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-  });
-  it('complete (101-byte chunks)', async () => {
-    const reader = await readerBrowser.CarReader.fromIterable(common.makeIterable(common.carBytes, 101));
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-  });
-  it('complete (64-byte chunks)', async () => {
-    const reader = await readerBrowser.CarReader.fromIterable(common.makeIterable(common.carBytes, 64));
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-  });
-  it('complete (32-byte chunks)', async () => {
-    const reader = await readerBrowser.CarReader.fromIterable(common.makeIterable(common.carBytes, 32));
-    await verifyStoreReader.verifyRoots(reader);
-    await verifyStoreReader.verifyHas(reader);
-    await verifyStoreReader.verifyGet(reader);
-    await verifyStoreReader.verifyBlocks(reader.blocks());
-    await verifyStoreReader.verifyCids(reader.cids());
-  });
-  it('handle zero-byte chunks', async () => {
-    const {writer, out} = await writerBrowser.CarWriter.create([]);
-    const b1 = await Block__namespace.encode({
-      value: Uint8Array.from([
-        0,
-        1,
-        2
-      ]),
-      hasher: sha2.sha256,
-      codec: raw__namespace
-    });
-    writer.put(b1);
-    const b2 = await Block__namespace.encode({
-      value: Uint8Array.from([]),
-      hasher: sha2.sha256,
-      codec: raw__namespace
-    });
-    writer.put(b2);
-    const b3 = await Block__namespace.encode({
-      value: Uint8Array.from([
-        3,
-        4,
-        5
-      ]),
-      hasher: sha2.sha256,
-      codec: raw__namespace
-    });
-    writer.put(b3);
-    const closePromise = writer.close();
-    const reader = await readerBrowser.CarReader.fromIterable(out);
-    const b1a = await reader.get(b1.cid);
-    common.assert.isDefined(b1a);
-    common.assert.deepStrictEqual(b1a && Array.from(b1a.bytes), [
-      0,
-      1,
-      2
-    ]);
-    const b2a = await reader.get(b2.cid);
-    common.assert.isDefined(b2a);
-    common.assert.deepStrictEqual(b2a && Array.from(b2a.bytes), []);
-    const b3a = await reader.get(b3.cid);
-    common.assert.isDefined(b3a);
-    common.assert.deepStrictEqual(b3a && Array.from(b3a.bytes), [
-      3,
-      4,
-      5
-    ]);
-    await closePromise;
-  });
-  it('bad argument', async () => {
-    for (const arg of [
-        new Uint8Array(0),
-        true,
-        false,
-        null,
-        undefined,
-        'string',
-        100,
-        { obj: 'nope' }
-      ]) {
-      await common.assert.isRejected(readerBrowser.CarReader.fromIterable(arg));
-    }
-  });
-  it('decode error - truncated', async () => {
-    await common.assert.isRejected(readerBrowser.CarReader.fromIterable(common.makeIterable(common.carBytes.slice(0, common.carBytes.length - 10), 64)), {
-      name: 'Error',
-      message: 'Unexpected end of data'
-    });
-  });
-  it('v2 decode error - truncated', async () => {
-    const bytes = common.goCarV2Bytes.slice();
-    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    dv.setBigUint64(35, BigInt(448 - 10), true);
-    await common.assert.isRejected(readerBrowser.CarReader.fromIterable(common.makeIterable(bytes, 64)), {
-      name: 'Error',
-      message: 'Unexpected end of data'
-    });
-  });
-});
-describe('Shared fixtures', () => {
-  describe('Header', () => {
-    for (const [name, {
-            version: expectedVersion,
-            err: expectedError
-          }] of Object.entries(fixturesExpectations.expectations)) {
-      it(name, async () => {
-        const data = base64.base64.baseDecode(fixtures.data[name]);
-        let header;
-        try {
-          header = await decoder.readHeader(decoder.bytesReader(data));
-        } catch (err) {
-          if (expectedError != null) {
-            common.assert.equal(err.message, expectedError);
-            return;
-          }
-          common.assert.ifError(err);
-        }
-        if (expectedError != null) {
-          common.assert.fail(`Expected error: ${ expectedError }`);
-        }
-        common.assert.isDefined(header, 'did not decode header');
-        if (expectedVersion != null && header != null) {
-          common.assert.strictEqual(header.version, expectedVersion);
-        }
-      });
-    }
-  });
-  describe('Contents', () => {
-    for (const [name, {cids: expectedCids}] of Object.entries(fixturesExpectations.expectations)) {
-      if (expectedCids == null) {
-        continue;
-      }
-      it(name, async () => {
-        const data = base64.base64.baseDecode(fixtures.data[name]);
-        const reader = await readerBrowser.CarReader.fromBytes(data);
-        let i = 0;
-        for await (const cid of reader.cids()) {
-          common.assert.strictEqual(cid.toString(), expectedCids[i++]);
-        }
-        common.assert.strictEqual(i, expectedCids.length);
-      });
-    }
-  });
-});

package/cjs/browser-test/test-writer.js

@@ -1,286 +0,0 @@
-'use strict';
-
-var writerBrowser = require('../lib/writer-browser.js');
-var readerBrowser = require('../lib/reader-browser.js');
-var multiformats = require('multiformats');
-var common = require('./common.js');
-var verifyStoreReader = require('./verify-store-reader.js');
-
-const {toHex} = multiformats.bytes;
-function concatBytes(chunks) {
-  const length = chunks.reduce((p, c) => p + c.length, 0);
-  const bytes = new Uint8Array(length);
-  let off = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, off);
-    off += chunk.length;
-  }
-  return bytes;
-}
-function collector(iterable) {
-  const chunks = [];
-  const cfn = (async () => {
-    for await (const chunk of iterable) {
-      chunks.push(chunk);
-    }
-    return concatBytes(chunks);
-  })();
-  return cfn;
-}
-const newRoots = [
-  multiformats.CID.parse('bafkreidbxzk2ryxwwtqxem4l3xyyjvw35yu4tcct4cqeqxwo47zhxgxqwq'),
-  multiformats.CID.parse('bafkreiebzrnroamgos2adnbpgw5apo3z4iishhbdx77gldnbk57d4zdio4')
-];
-async function verifyUpdateRoots(bytes) {
-  const reader = await readerBrowser.CarReader.fromBytes(bytes);
-  await common.assert.isRejected(verifyStoreReader.verifyRoots(reader));
-  common.assert.deepEqual(await reader.getRoots(), newRoots);
-  await verifyStoreReader.verifyHas(reader);
-  await verifyStoreReader.verifyGet(reader);
-  await verifyStoreReader.verifyBlocks(reader.blocks(), true);
-  await verifyStoreReader.verifyCids(reader.cids(), true);
-}
-describe('CarWriter', () => {
-  let cborBlocks;
-  let allBlocks;
-  let allBlocksFlattened;
-  let roots;
-  function assertCarData(actual) {
-    common.assert.strictEqual(toHex(actual), toHex(common.carBytes), 'got expected bytes');
-  }
-  before(async () => {
-    const data = await common.makeData();
-    cborBlocks = data.cborBlocks;
-    allBlocks = data.allBlocks;
-    allBlocksFlattened = data.allBlocksFlattened;
-    roots = [
-      cborBlocks[0].cid,
-      cborBlocks[1].cid
-    ];
-  });
-  it('complete', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    common.assert.strictEqual(typeof out[Symbol.asyncIterator], 'function');
-    const collection = collector(out);
-    const writeQueue = [];
-    for (const block of allBlocksFlattened) {
-      writeQueue.push(writer.put(block));
-    }
-    writeQueue.push(writer.close());
-    let collected = false;
-    collection.then(bytes => {
-      collected = true;
-      assertCarData(bytes);
-    });
-    await Promise.all(writeQueue);
-    common.assert.strictEqual(collected, true);
-  });
-  it('complete, deferred collection', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    const writeQueue = [];
-    for (const block of allBlocksFlattened) {
-      writeQueue.push(writer.put(block));
-    }
-    writeQueue.push(writer.close());
-    let collected = false;
-    collector(out).then(bytes => {
-      collected = true;
-      assertCarData(bytes);
-    });
-    await Promise.all(writeQueue);
-    common.assert.strictEqual(collected, true);
-  });
-  it('complete, close after write', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    common.assert.strictEqual(typeof out[Symbol.asyncIterator], 'function');
-    const collection = collector(out);
-    const writeQueue = [];
-    for (const block of allBlocksFlattened) {
-      writeQueue.push(writer.put(block));
-    }
-    writeQueue.push(writer.close());
-    let written = false;
-    Promise.all(writeQueue).then(() => {
-      written = true;
-    });
-    const bytes = await collection;
-    common.assert.strictEqual(written, false);
-    await Promise.resolve();
-    assertCarData(bytes);
-  });
-  it('complete, no queue', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    const collection = collector(out);
-    for (const block of allBlocksFlattened) {
-      await writer.put(block);
-    }
-    await writer.close();
-    const bytes = await collection;
-    assertCarData(bytes);
-  });
-  it('complete, slow drip', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    common.assert.strictEqual(typeof out[Symbol.asyncIterator], 'function');
-    const collection = collector(out);
-    for (const block of allBlocksFlattened) {
-      writer.put(block);
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    await writer.close();
-    await new Promise(resolve => setTimeout(resolve, 100));
-    const bytes = await collection;
-    assertCarData(bytes);
-  });
-  it('complete, no queue, deferred collection', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots);
-    for (const block of allBlocksFlattened) {
-      writer.put(block);
-    }
-    writer.close();
-    const collection = collector(out);
-    const bytes = await collection;
-    assertCarData(bytes);
-  });
-  it('single root', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create(roots[0]);
-    const collection = collector(out);
-    for (const block of allBlocksFlattened) {
-      await writer.put(block);
-    }
-    await writer.close();
-    const bytes = await collection;
-    const expectedRootDef = 'a265726f6f747381d82a58250001711220f88bc853804cf294fe417e4fa83028689fcdb1b1592c5102e1474dbc200fab8b6776657273696f6e01';
-    const expectedStart = (expectedRootDef.length / 2).toString(16) + expectedRootDef + '28';
-    common.assert.strictEqual(toHex(bytes).substring(0, expectedStart.length), expectedStart);
-  });
-  it('no roots', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create();
-    const collection = collector(out);
-    for (const block of allBlocksFlattened) {
-      await writer.put(block);
-    }
-    await writer.close();
-    const bytes = await collection;
-    const expectedRootDef = 'a265726f6f7473806776657273696f6e01';
-    const expectedStart = (expectedRootDef.length / 2).toString(16) + expectedRootDef + '28';
-    common.assert.strictEqual(toHex(bytes).substring(0, expectedStart.length), expectedStart);
-  });
-  it('appender', async () => {
-    let writerOut = writerBrowser.CarWriter.create(roots);
-    let collection = collector(writerOut.out);
-    await writerOut.writer.close();
-    const headerBytes = await collection;
-    const append = async index => {
-      writerOut = writerBrowser.CarWriter.createAppender();
-      collection = collector(writerOut.out);
-      for (const block of allBlocks[index][1]) {
-        await writerOut.writer.put(block);
-      }
-      await writerOut.writer.close();
-      return collection;
-    };
-    const rawBytes = await append(0);
-    const pbBytes = await append(1);
-    const cborBytes = await append(2);
-    common.assert.ok(rawBytes.length > 0);
-    common.assert.ok(pbBytes.length > 0);
-    common.assert.ok(cborBytes.length > 0);
-    const reassembled = concatBytes([
-      headerBytes,
-      rawBytes,
-      pbBytes,
-      cborBytes
-    ]);
-    common.assert.strictEqual(toHex(reassembled), toHex(common.carBytes));
-  });
-  it('bad argument for create()', () => {
-    for (const arg of [
-        new Uint8Array(0),
-        true,
-        false,
-        null,
-        'string',
-        100,
-        { obj: 'nope' },
-        [false]
-      ]) {
-      common.assert.throws(() => writerBrowser.CarWriter.create(arg));
-    }
-  });
-  it('bad argument for put()', async () => {
-    const {writer} = writerBrowser.CarWriter.create();
-    for (const arg of [
-        new Uint8Array(0),
-        true,
-        false,
-        null,
-        'string',
-        100,
-        { obj: 'nope' },
-        [false]
-      ]) {
-      await common.assert.isRejected(writer.put(arg));
-    }
-    for (const arg of [
-        true,
-        false,
-        null,
-        'string',
-        100,
-        { obj: 'nope' },
-        [false]
-      ]) {
-      await common.assert.isRejected(writer.put({
-        bytes: new Uint8Array(0),
-        cid: arg
-      }));
-    }
-    for (const arg of [
-        true,
-        false,
-        null,
-        'string',
-        100,
-        { obj: 'nope' },
-        [false]
-      ]) {
-      await common.assert.isRejected(writer.put({
-        cid: common.rndCid,
-        bytes: arg
-      }));
-    }
-  });
-  it('bad write after closed', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create();
-    const collection = collector(out);
-    await writer.put(allBlocksFlattened[0]);
-    await writer.close();
-    await common.assert.isRejected(writer.put(allBlocksFlattened[1]), /closed/);
-    await collection;
-  });
-  it('bad attempt to multiple iterate', async () => {
-    const {out} = writerBrowser.CarWriter.create();
-    collector(out);
-    await common.assert.isRejected(collector(out), /multiple iterator/i);
-  });
-  it('bad attempt to multiple close', async () => {
-    const {writer, out} = writerBrowser.CarWriter.create();
-    collector(out);
-    await writer.close();
-    await common.assert.isRejected(writer.close(), /closed/i);
-  });
-  it('update roots (fd)', async () => {
-    const bytes = common.carBytes.slice();
-    await writerBrowser.CarWriter.updateRootsInBytes(bytes, newRoots);
-    await verifyUpdateRoots(bytes);
-  });
-  it('update roots error: wrong header size', async () => {
-    const bytes = common.carBytes.slice();
-    await common.assert.isRejected(writerBrowser.CarWriter.updateRootsInBytes(bytes, [
-      ...newRoots,
-      newRoots[0]
-    ]), /can only overwrite a header of the same length/);
-    await common.assert.isRejected(writerBrowser.CarWriter.updateRootsInBytes(bytes, [newRoots[0]]), /can only overwrite a header of the same length/);
-    await common.assert.isRejected(writerBrowser.CarWriter.updateRootsInBytes(bytes, []), /can only overwrite a header of the same length/);
-  });
-});

package/cjs/browser-test/verify-store-reader.js

@@ -1,142 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var multiformats = require('multiformats');
-var raw = require('multiformats/codecs/raw');
-var common = require('./common.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
-
-function compareBlockData(actual, expected, id) {
-  common.assert.strictEqual(multiformats.bytes.toHex(actual.bytes), multiformats.bytes.toHex(expected.bytes), `comparing block as hex ${ id || '' }`);
-}
-function compareCids(actual, expected) {
-  common.assert.strictEqual(actual.toString(), expected.toString());
-}
-async function verifyRoots(reader) {
-  const {cborBlocks} = await common.makeData();
-  const expected = [
-    cborBlocks[0].cid.toString(),
-    cborBlocks[1].cid.toString()
-  ];
-  common.assert.deepStrictEqual((await reader.getRoots()).map(c => c.toString()), expected);
-}
-async function verifyHas(reader) {
-  const {allBlocks} = await common.makeData();
-  const verifyHas = async (cid, name) => {
-    common.assert.ok(await reader.has(cid), `reader doesn't have expected key for ${ name }`);
-  };
-  const verifyHasnt = async (cid, name) => {
-    common.assert.ok(!await reader.has(cid), `reader has unexpected key for ${ name }`);
-    common.assert.strictEqual(await reader.get(cid), undefined);
-  };
-  for (const [type, blocks] of allBlocks) {
-    for (let i = 0; i < blocks.length; i++) {
-      await verifyHas(blocks[i].cid, `block #${ i } (${ type } / ${ blocks[i].cid })`);
-    }
-  }
-  await verifyHasnt((await common.toBlock(new TextEncoder().encode('dddd'), raw__namespace)).cid, 'dddd');
-}
-async function verifyGet(reader) {
-  const {allBlocks} = await common.makeData();
-  const verifyBlock = async (expected, index, type) => {
-    let actual;
-    try {
-      actual = await reader.get(expected.cid);
-      common.assert.isDefined(actual);
-      if (actual) {
-        compareBlockData(actual, expected, `#${ index } (${ type })`);
-      }
-    } catch (err) {
-      common.assert.ifError(err, `get block length #${ index } (${ type })`);
-    }
-  };
-  for (const [type, blocks] of allBlocks) {
-    for (let i = 0; i < blocks.length; i++) {
-      await verifyBlock(blocks[i], i, type);
-    }
-  }
-}
-async function verifyBlocks(iterator, unordered) {
-  const {allBlocksFlattened} = await common.makeData();
-  if (!unordered) {
-    const expected = allBlocksFlattened.slice();
-    for await (const actual of iterator) {
-      const next = expected.shift();
-      common.assert.isDefined(next);
-      if (next) {
-        compareBlockData(actual, next);
-      }
-    }
-  } else {
-    const expected = {};
-    for (const block of allBlocksFlattened) {
-      expected[block.cid.toString()] = block;
-    }
-    for await (const actual of iterator) {
-      const {cid} = actual;
-      const exp = expected[cid.toString()];
-      if (!exp) {
-        throw new Error(`Unexpected block: ${ cid.toString() }`);
-      }
-      compareBlockData(actual, exp);
-      delete expected[cid.toString()];
-    }
-    if (Object.keys(expected).length) {
-      throw new Error('Did not find all expected blocks');
-    }
-  }
-}
-async function verifyCids(iterator, unordered) {
-  const {allBlocksFlattened} = await common.makeData();
-  if (!unordered) {
-    const expected = allBlocksFlattened.slice();
-    for await (const actual of iterator) {
-      const next = expected.shift();
-      common.assert.isDefined(next);
-      if (next) {
-        compareCids(actual, next.cid);
-      }
-    }
-  } else {
-    const expected = {};
-    for (const block of allBlocksFlattened) {
-      expected[block.cid.toString()] = block;
-    }
-    for await (const cid of iterator) {
-      const exp = expected[cid.toString()];
-      if (!exp) {
-        throw new Error(`Unexpected cid: ${ cid.toString() }`);
-      }
-      delete expected[cid.toString()];
-    }
-    if (Object.keys(expected).length) {
-      throw new Error('Did not find all expected cids');
-    }
-  }
-}
-
-exports.verifyBlocks = verifyBlocks;
-exports.verifyCids = verifyCids;
-exports.verifyGet = verifyGet;
-exports.verifyHas = verifyHas;
-exports.verifyRoots = verifyRoots;