@ipld/car 4.1.6 → 5.0.1

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

@@ -1,45 +0,0 @@
-/* eslint-env mocha */
-
-import path from 'path'
-import { fileURLToPath } from 'url'
-import { CarIndexedReader } from '@ipld/car/indexed-reader'
-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)
-    // now verify the ordering is correct
-    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' }]) {
-      // @ts-ignore
-      await assert.isRejected(CarIndexedReader.fromFile(arg))
-    }
-  })
-})

package/test/node-test-large.js

@@ -1,112 +0,0 @@
-/* eslint-env mocha */
-
-// this test is not intended to run in the browser
-
-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 '@ipld/car'
-import { assert } from './common.js'
-
-/** @typedef {import('../api').BlockIndex} BlockIndex */
-
-describe('Large CAR', () => {
-  /** @type {any[]} */
-  const objects = []
-  /** @type {string[]} */
-  const cids = []
-  /** @type {BlockIndex[]} */
-  const expectedIndex = []
-
-  it('create, no roots', async () => {
-    const { writer, out } = CarWriter.create([])
-    Readable.from(out).pipe(fs.createWriteStream('./test.car'))
-
-    // offset starts at header length
-    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/test/node-test-raw.js

@@ -1,83 +0,0 @@
-/* eslint-env mocha */
-
-// this test is not intended to run in the browser
-
-import path from 'path'
-import fs from 'fs'
-import { promisify } from 'util'
-import { fileURLToPath } from 'url'
-import { bytes } from 'multiformats'
-import { CarReader } from '@ipld/car'
-import { assert, makeData, goCarIndex } from './common.js'
-
-/** @typedef {import('../api').Block} Block */
-
-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', () => {
-  /** @type {Block[]} */
-  let allBlocksFlattened
-
-  before(async () => {
-    const data = await makeData()
-    allBlocksFlattened = data.allBlocksFlattened
-  })
-
-  /**
-   * @param {fs.promises.FileHandle | number} fd
-   */
-  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 () => {
-    // @ts-ignore
-    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/test/node-test-updateroots.js

@@ -1,89 +0,0 @@
-/* eslint-env mocha */
-
-// this test is not intended to run in the browser
-
-import path from 'path'
-import { fileURLToPath } from 'url'
-import fs from 'fs'
-import { promisify } from 'util'
-import { CID } from 'multiformats/cid'
-import { CarReader } from '@ipld/car/reader'
-import { CarWriter } from '@ipld/car/writer'
-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)) // whoa, different roots? like magic
-  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 () => {
-    // @ts-ignore
-    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/test/test-buffer-writer.js

@@ -1,256 +0,0 @@
-/* eslint-env mocha */
-
-import * as CarBufferWriter from '@ipld/car/buffer-writer'
-import { CarReader } from '@ipld/car/reader'
-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/test/test-errors.js

@@ -1,98 +0,0 @@
-/* eslint-env mocha */
-import { bytes } from 'multiformats'
-import { encode as cbEncode } from '@ipld/dag-cbor'
-import { encode as vEncode } from 'varint'
-import { CarReader } from '@ipld/car/reader'
-import { carBytes, assert, goCarV2Bytes } from './common.js'
-
-/**
- * @param {any} block
- * @returns {Uint8Array}
- */
-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 () => {
-    // cid v0
-    const buf2 = new Uint8Array(buf.length)
-    buf2.set(buf, 0)
-    buf2[101] = 0 // first block's CID
-    await assert.isRejected(CarReader.fromBytes(buf2), {
-      name: 'Error',
-      message: 'Unexpected CID version (0)'
-    })
-  })
-
-  it('bad version', async () => {
-    // quick sanity check that makeHeader() works properly!
-    const buf2 = bytes.fromHex('0aa16776657273696f6e03')
-    assert.strictEqual(bytes.toHex(makeHeader({ version: 3 })), '0aa16776657273696f6e03')
-    // {version:3}
-    await assert.isRejected(CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 3')
-  })
-
-  describe('bad header', async () => {
-    it('sanity check', async () => {
-      // sanity check, this should be fine
-      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 () => {
-      // first 51 bytes are the carv2 header:
-      //   11b prefix, 16b characteristics, 8b data offset, 8b data size, 8b index offset
-      const v2Header = goCarV2Bytes.slice(0, 51)
-      // parser should expect to get a carv1 header at the data offset, but it uses the same
-      // code to check the carv2 header so let's make sure it doesn't allow recursive carv2
-      // headers
-      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)')
-    })
-  })
-})