@ipld/car 4.1.6 → 5.0.1

package/esm/node-test/node-test-indexed-reader.js

@@ -1,53 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { CarIndexedReader } from '../lib/indexed-reader.js';
-import {
-  assert,
-  goCarIndex
-} from './common.js';
-import {
-  verifyRoots,
-  verifyHas,
-  verifyGet,
-  verifyBlocks,
-  verifyCids
-} from './verify-store-reader.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-describe('CarIndexedReader fromFile()', () => {
-  it('complete', async () => {
-    const reader = await CarIndexedReader.fromFile(path.join(__dirname, 'go.car'));
-    await verifyRoots(reader);
-    await verifyHas(reader);
-    await verifyGet(reader);
-    await verifyBlocks(reader.blocks(), true);
-    await verifyCids(reader.cids(), true);
-    let i = 0;
-    for await (const block of reader.blocks()) {
-      assert.strictEqual(block.cid.toString(), goCarIndex[i++].cid.toString());
-    }
-    i = 0;
-    for await (const cid of reader.cids()) {
-      assert.strictEqual(cid.toString(), goCarIndex[i++].cid.toString());
-    }
-    assert.strictEqual(reader.version, 1);
-    await reader.close();
-  });
-  it('bad argument', async () => {
-    for (const arg of [
-        true,
-        false,
-        null,
-        undefined,
-        Uint8Array.from([
-          1,
-          2,
-          3
-        ]),
-        100,
-        { obj: 'nope' }
-      ]) {
-      await assert.isRejected(CarIndexedReader.fromFile(arg));
-    }
-  });
-});

package/esm/node-test/node-test-large.js

@@ -1,109 +0,0 @@
-import fs from 'fs';
-import { Readable } from 'stream';
-import { garbage } from 'ipld-garbage';
-import varint from 'varint';
-import * as dagCbor from '@ipld/dag-cbor';
-import { sha256 } from 'multiformats/hashes/sha2';
-import { CID } from 'multiformats/cid';
-import {
-  CarWriter,
-  CarIndexer,
-  CarReader,
-  CarIndexedReader
-} from '../car.js';
-import { assert } from './common.js';
-describe('Large CAR', () => {
-  const objects = [];
-  const cids = [];
-  const expectedIndex = [];
-  it('create, no roots', async () => {
-    const {writer, out} = CarWriter.create([]);
-    Readable.from(out).pipe(fs.createWriteStream('./test.car'));
-    let offset = dagCbor.encode({
-      version: 1,
-      roots: []
-    }).length;
-    offset += varint.encode(offset).length;
-    for (let i = 0; i < 500; i++) {
-      const obj = garbage(1000);
-      objects.push(obj);
-      const bytes = dagCbor.encode(obj);
-      const hash = await sha256.digest(bytes);
-      const cid = CID.create(1, dagCbor.code, hash);
-      cids.push(cid.toString());
-      const blockLength = bytes.length;
-      let length = cid.bytes.length + blockLength;
-      const lengthLength = varint.encode(length).length;
-      length += lengthLength;
-      const blockOffset = offset + lengthLength + cid.bytes.length;
-      expectedIndex.push({
-        cid,
-        offset,
-        length,
-        blockOffset,
-        blockLength
-      });
-      offset += length;
-      await writer.put({
-        cid,
-        bytes
-      });
-    }
-    await writer.close();
-  });
-  it('CarIndexer.fromIterable', async () => {
-    const indexer = await CarIndexer.fromIterable(fs.createReadStream('./test.car'));
-    assert.deepStrictEqual(await indexer.getRoots(), []);
-    let i = 0;
-    for await (const blockIndex of indexer) {
-      assert.deepStrictEqual(blockIndex, expectedIndex[i]);
-      i++;
-    }
-  });
-  it('CarIndexer.fromBytes', async () => {
-    const indexer = await CarIndexer.fromBytes(await fs.promises.readFile('./test.car'));
-    assert.deepStrictEqual(await indexer.getRoots(), []);
-    let i = 0;
-    for await (const blockIndex of indexer) {
-      assert.deepStrictEqual(blockIndex, expectedIndex[i]);
-      i++;
-    }
-  });
-  it('CarReader.fromBytes', async () => {
-    const reader = await CarReader.fromBytes(await fs.promises.readFile('./test.car'));
-    assert.deepStrictEqual(await reader.getRoots(), []);
-    let i = 0;
-    for await (const {cid, bytes} of reader.blocks()) {
-      assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor.decode(bytes);
-      assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
-      i++;
-    }
-  });
-  it('CarReader.fromIterable', async () => {
-    const reader = await CarReader.fromIterable(fs.createReadStream('./test.car'));
-    assert.deepStrictEqual(await reader.getRoots(), []);
-    let i = 0;
-    for await (const {cid, bytes} of reader.blocks()) {
-      assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor.decode(bytes);
-      assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
-      i++;
-    }
-  });
-  it('CarIndexedReader.fromFile', async () => {
-    const reader = await CarIndexedReader.fromFile('./test.car');
-    assert.deepStrictEqual(await reader.getRoots(), []);
-    let i = 0;
-    for await (const {cid, bytes} of reader.blocks()) {
-      assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor.decode(bytes);
-      assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
-      i++;
-    }
-  });
-  after(async () => {
-    return fs.promises.unlink('./test.car').catch(() => {
-    });
-  });
-});

package/esm/node-test/node-test-raw.js

@@ -1,63 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { promisify } from 'util';
-import { fileURLToPath } from 'url';
-import { bytes } from 'multiformats';
-import { CarReader } from '../car.js';
-import {
-  assert,
-  makeData,
-  goCarIndex
-} from './common.js';
-const fsopen = promisify(fs.open);
-const fsclose = promisify(fs.close);
-const {toHex} = bytes;
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-describe('CarReader.readRaw', () => {
-  let allBlocksFlattened;
-  before(async () => {
-    const data = await makeData();
-    allBlocksFlattened = data.allBlocksFlattened;
-  });
-  async function verifyRead(fd) {
-    const expectedBlocks = allBlocksFlattened.slice();
-    const expectedCids = [];
-    for (const {cid} of expectedBlocks) {
-      expectedCids.push(cid.toString());
-    }
-    for (const blockIndex of goCarIndex) {
-      const {cid, bytes} = await CarReader.readRaw(fd, blockIndex);
-      const index = expectedCids.indexOf(cid.toString());
-      assert.ok(index >= 0, 'got expected block');
-      assert.strictEqual(toHex(expectedBlocks[index].bytes), toHex(bytes), 'got expected block content');
-      expectedBlocks.splice(index, 1);
-      expectedCids.splice(index, 1);
-    }
-    assert.strictEqual(expectedBlocks.length, 0, 'got all expected blocks');
-  }
-  it('read raw using index (fd)', async () => {
-    const fd = await fsopen(path.join(__dirname, 'go.car'), 'r');
-    await verifyRead(fd);
-    await fsclose(fd);
-  });
-  it('read raw using index (FileHandle)', async () => {
-    const fd = await fs.promises.open(path.join(__dirname, 'go.car'), 'r');
-    await verifyRead(fd);
-    await fd.close();
-  });
-  it('errors', async () => {
-    await assert.isRejected(CarReader.readRaw(true, goCarIndex[0]), {
-      name: 'TypeError',
-      message: 'Bad fd'
-    });
-    const badBlock = Object.assign({}, goCarIndex[goCarIndex.length - 1]);
-    badBlock.blockLength += 10;
-    const fd = await fsopen(path.join(__dirname, 'go.car'), 'r');
-    await assert.isRejected(CarReader.readRaw(fd, badBlock), {
-      name: 'Error',
-      message: `Failed to read entire block (${ badBlock.blockLength - 10 } instead of ${ badBlock.blockLength })`
-    });
-    await fsclose(fd);
-  });
-});

package/esm/node-test/node-test-updateroots.js

@@ -1,76 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs';
-import { promisify } from 'util';
-import { CID } from 'multiformats/cid';
-import { CarReader } from '../lib/reader.js';
-import { CarWriter } from '../lib/writer.js';
-import {
-  verifyRoots,
-  verifyHas,
-  verifyGet,
-  verifyBlocks,
-  verifyCids
-} from './verify-store-reader.js';
-import { assert } from './common.js';
-const fsopen = promisify(fs.open);
-const fsclose = promisify(fs.close);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const goCarPath = path.join(__dirname, 'go.car');
-const tmpCarPath = path.join(__dirname, 'tmp.car');
-const newRoots = [
-  CID.parse('bafkreidbxzk2ryxwwtqxem4l3xyyjvw35yu4tcct4cqeqxwo47zhxgxqwq'),
-  CID.parse('bafkreiebzrnroamgos2adnbpgw5apo3z4iishhbdx77gldnbk57d4zdio4')
-];
-async function verify() {
-  const reader = await CarReader.fromIterable(fs.createReadStream(tmpCarPath));
-  await assert.isRejected(verifyRoots(reader));
-  assert.deepEqual(await reader.getRoots(), newRoots);
-  await verifyHas(reader);
-  await verifyGet(reader);
-  await verifyBlocks(reader.blocks(), true);
-  await verifyCids(reader.cids(), true);
-}
-describe('Node CarWriter.updateHeader()', () => {
-  before(async () => {
-    try {
-      await fs.promises.unlink(tmpCarPath);
-    } catch (e) {
-    }
-  });
-  beforeEach(async () => {
-    await fs.promises.copyFile(goCarPath, tmpCarPath);
-  });
-  afterEach(async () => {
-    await fs.promises.unlink(tmpCarPath);
-  });
-  it('update roots (fd)', async () => {
-    const fd = await fsopen(tmpCarPath, 'r+');
-    await CarWriter.updateRootsInFile(fd, newRoots);
-    await fsclose(fd);
-    await verify();
-  });
-  it('update roots (FileHandle)', async () => {
-    const fd = await fs.promises.open(tmpCarPath, 'r+');
-    await CarWriter.updateRootsInFile(fd, newRoots);
-    await fd.close();
-    await verify();
-  });
-  it('error: bad fd', async () => {
-    await assert.isRejected(CarWriter.updateRootsInFile(true, newRoots), {
-      name: 'TypeError',
-      message: 'Bad fd'
-    });
-  });
-  it('error: wrong header size', async () => {
-    const fd = await fs.promises.open(tmpCarPath, 'r+');
-    await assert.isRejected(CarWriter.updateRootsInFile(fd, [
-      ...newRoots,
-      newRoots[0]
-    ]), /can only overwrite a header of the same length/);
-    await assert.isRejected(CarWriter.updateRootsInFile(fd, [newRoots[0]]), /can only overwrite a header of the same length/);
-    await assert.isRejected(CarWriter.updateRootsInFile(fd, []), /can only overwrite a header of the same length/);
-    await fd.close();
-  });
-});

package/esm/node-test/test-buffer-writer.js

@@ -1,311 +0,0 @@
-import * as CarBufferWriter from '../lib/buffer-writer.js';
-import { CarReader } from '../lib/reader.js';
-import { createHeader } from '../lib/encoder.js';
-import { assert } from './common.js';
-import {
-  CID,
-  varint
-} from 'multiformats';
-import * as CBOR from '@ipld/dag-cbor';
-import {
-  sha256,
-  sha512
-} from 'multiformats/hashes/sha2';
-import { identity } from 'multiformats/hashes/identity';
-import * as Raw from 'multiformats/codecs/raw';
-import * as Block from 'multiformats/block';
-describe('CarBufferWriter', () => {
-  const cid = CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu');
-  describe('calculateHeaderLength', async () => {
-    for (const count of [
-        0,
-        1,
-        10,
-        18,
-        24,
-        48,
-        124,
-        255,
-        258,
-        65536 - 1,
-        65536
-      ]) {
-      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
-        const roots = new Array(count).fill(cid);
-        const sizes = new Array(count).fill(cid.bytes.byteLength);
-        assert.deepEqual(CarBufferWriter.calculateHeaderLength(sizes), createHeader(roots).byteLength);
-      });
-      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
-        const roots = new Array(count).fill(cid);
-        const rootLengths = roots.map(c => c.bytes.byteLength);
-        assert.deepEqual(CarBufferWriter.calculateHeaderLength(rootLengths), createHeader(roots).byteLength);
-      });
-    }
-    it('estimate on large CIDs', () => {
-      const largeCID = CID.parse(`bafkqbbac${ 'a'.repeat(416) }`);
-      assert.equal(CarBufferWriter.calculateHeaderLength([
-        cid.bytes.byteLength,
-        largeCID.bytes.byteLength
-      ]), createHeader([
-        cid,
-        largeCID
-      ]).byteLength);
-    });
-    it('estimate on large CIDs 2', () => {
-      const largeCID = CID.createV1(Raw.code, identity.digest(new Uint8Array(512).fill(1)));
-      assert.equal(CarBufferWriter.calculateHeaderLength([
-        cid.bytes.byteLength,
-        largeCID.bytes.byteLength
-      ]), createHeader([
-        cid,
-        largeCID
-      ]).byteLength);
-    });
-  });
-  describe('writer', () => {
-    it('estimate header and write blocks', async () => {
-      const headerSize = CarBufferWriter.estimateHeaderLength(1);
-      const dataSize = 256;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = CarBufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block.encode({
-        value: { hello: 'world' },
-        codec: CBOR,
-        hasher: sha256
-      });
-      writer.write(b1);
-      const b2 = await Block.encode({
-        value: { bye: 'world' },
-        codec: CBOR,
-        hasher: sha256
-      });
-      writer.write(b2);
-      writer.addRoot(b1.cid);
-      const bytes = writer.close();
-      const reader = await CarReader.fromBytes(bytes);
-      assert.deepEqual(await reader.getRoots(), [b1.cid]);
-      assert.deepEqual(reader._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-    it('overestimate header', async () => {
-      const headerSize = CarBufferWriter.estimateHeaderLength(2);
-      const dataSize = 256;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = CarBufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block.encode({
-        value: { hello: 'world' },
-        codec: CBOR,
-        hasher: sha256
-      });
-      writer.write(b1);
-      const b2 = await Block.encode({
-        value: { bye: 'world' },
-        codec: CBOR,
-        hasher: sha256
-      });
-      writer.write(b2);
-      writer.addRoot(b1.cid);
-      assert.throws(() => writer.close(), /Header size was overestimate/);
-      const bytes = writer.close({ resize: true });
-      const reader = await CarReader.fromBytes(bytes);
-      assert.deepEqual(await reader.getRoots(), [b1.cid]);
-      assert.deepEqual(reader._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-    it('underestimate header', async () => {
-      const headerSize = CarBufferWriter.estimateHeaderLength(2);
-      const dataSize = 300;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = CarBufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block.encode({
-        value: { hello: 'world' },
-        codec: CBOR,
-        hasher: sha256
-      });
-      writer.write(b1);
-      writer.addRoot(b1.cid);
-      const b2 = await Block.encode({
-        value: { bye: 'world' },
-        codec: CBOR,
-        hasher: sha512
-      });
-      writer.write(b2);
-      assert.throws(() => writer.addRoot(b2.cid), /has no capacity/);
-      writer.addRoot(b2.cid, { resize: true });
-      const bytes = writer.close();
-      const reader = await CarReader.fromBytes(bytes);
-      assert.deepEqual(await reader.getRoots(), [
-        b1.cid,
-        b2.cid
-      ]);
-      assert.deepEqual(reader._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-  });
-  it('has no space for the root', async () => {
-    const headerSize = CarBufferWriter.estimateHeaderLength(1);
-    const dataSize = 100;
-    const buffer = new ArrayBuffer(headerSize + dataSize);
-    const writer = CarBufferWriter.createWriter(buffer, { headerSize });
-    const b1 = await Block.encode({
-      value: { hello: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    writer.write(b1);
-    writer.addRoot(b1.cid);
-    const b2 = await Block.encode({
-      value: { bye: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    writer.write(b2);
-    assert.throws(() => writer.addRoot(b2.cid), /Buffer has no capacity for a new root/);
-    assert.throws(() => writer.addRoot(b2.cid, { resize: true }), /Buffer has no capacity for a new root/);
-    const bytes = writer.close();
-    const reader = await CarReader.fromBytes(bytes);
-    assert.deepEqual(await reader.getRoots(), [b1.cid]);
-    assert.deepEqual(reader._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-  it('has no space for the block', async () => {
-    const headerSize = CarBufferWriter.estimateHeaderLength(1);
-    const dataSize = 58;
-    const buffer = new ArrayBuffer(headerSize + dataSize);
-    const writer = CarBufferWriter.createWriter(buffer, { headerSize });
-    const b1 = await Block.encode({
-      value: { hello: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    writer.write(b1);
-    writer.addRoot(b1.cid);
-    const b2 = await Block.encode({
-      value: { bye: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    assert.throws(() => writer.write(b2), /Buffer has no capacity for this block/);
-    const bytes = writer.close();
-    const reader = await CarReader.fromBytes(bytes);
-    assert.deepEqual(await reader.getRoots(), [b1.cid]);
-    assert.deepEqual(reader._blocks, [{
-        cid: b1.cid,
-        bytes: b1.bytes
-      }]);
-  });
-  it('provide roots', async () => {
-    const b1 = await Block.encode({
-      value: { hello: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    const b2 = await Block.encode({
-      value: { bye: 'world' },
-      codec: CBOR,
-      hasher: sha512
-    });
-    const buffer = new ArrayBuffer(300);
-    const writer = CarBufferWriter.createWriter(buffer, {
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    });
-    writer.write(b1);
-    writer.write(b2);
-    const bytes = writer.close();
-    const reader = await CarReader.fromBytes(bytes);
-    assert.deepEqual(await reader.getRoots(), [
-      b1.cid,
-      b2.cid
-    ]);
-    assert.deepEqual(reader._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-  it('provide large CID root', async () => {
-    const bytes = new Uint8Array(512).fill(1);
-    const b1 = await Block.encode({
-      value: { hello: 'world' },
-      codec: CBOR,
-      hasher: sha256
-    });
-    const b2 = {
-      cid: CID.createV1(Raw.code, identity.digest(bytes)),
-      bytes
-    };
-    const headerSize = CBOR.encode({
-      version: 1,
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    }).byteLength;
-    const bodySize = CarBufferWriter.blockLength(b1) + CarBufferWriter.blockLength(b2);
-    const varintSize = varint.encodingLength(headerSize);
-    const writer = CarBufferWriter.createWriter(new ArrayBuffer(varintSize + headerSize + bodySize), {
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    });
-    writer.write(b1);
-    writer.write(b2);
-    const car = writer.close();
-    const reader = await CarReader.fromBytes(car);
-    assert.deepEqual(await reader.getRoots(), [
-      b1.cid,
-      b2.cid
-    ]);
-    assert.deepEqual(reader._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-});

package/esm/node-test/test-errors.js

@@ -1,91 +0,0 @@
-import { bytes } from 'multiformats';
-import { encode as cbEncode } from '@ipld/dag-cbor';
-import { encode as vEncode } from 'varint';
-import { CarReader } from '../lib/reader.js';
-import {
-  carBytes,
-  assert,
-  goCarV2Bytes
-} from './common.js';
-function makeHeader(block) {
-  const u = cbEncode(block);
-  const l = vEncode(u.length);
-  const u2 = new Uint8Array(u.length + l.length);
-  u2.set(l, 0);
-  u2.set(u, l.length);
-  return u2;
-}
-describe('Misc errors', () => {
-  const buf = carBytes.slice();
-  it('decode errors', async () => {
-    const buf2 = new Uint8Array(buf.length);
-    buf2.set(buf, 0);
-    buf2[101] = 0;
-    await assert.isRejected(CarReader.fromBytes(buf2), {
-      name: 'Error',
-      message: 'Unexpected CID version (0)'
-    });
-  });
-  it('bad version', async () => {
-    const buf2 = bytes.fromHex('0aa16776657273696f6e03');
-    assert.strictEqual(bytes.toHex(makeHeader({ version: 3 })), '0aa16776657273696f6e03');
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 3');
-  });
-  describe('bad header', async () => {
-    it('sanity check', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: []
-      });
-      await assert.isFulfilled(CarReader.fromBytes(buf2));
-    });
-    it('no \'version\' array', async () => {
-      const buf2 = makeHeader({ roots: [] });
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('bad \'version\' type', async () => {
-      const buf2 = makeHeader({
-        version: '1',
-        roots: []
-      });
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('no \'roots\' array', async () => {
-      const buf2 = makeHeader({ version: 1 });
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('bad \'roots\' type', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: {}
-      });
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('extraneous properties', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: [],
-        blip: true
-      });
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('not an object', async () => {
-      const buf2 = makeHeader([
-        1,
-        []
-      ]);
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('not an object', async () => {
-      const buf2 = makeHeader(null);
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('recursive v2 header', async () => {
-      const v2Header = goCarV2Bytes.slice(0, 51);
-      const buf2 = new Uint8Array(51 * 2);
-      buf2.set(v2Header, 0);
-      buf2.set(v2Header, 51);
-      await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2 (expected 1)');
-    });
-  });
-});