@ipld/car 4.1.6 → 5.0.0

package/test/test-indexer.js

@@ -1,87 +0,0 @@
-/* eslint-env mocha */
-
-import { CarIndexer } from '@ipld/car/indexer'
-import {
-  goCarBytes,
-  goCarIndex,
-  goCarV2Bytes,
-  goCarV2Roots,
-  goCarV2Index,
-  makeIterable,
-  assert
-} from './common.js'
-import { verifyRoots } from './verify-store-reader.js'
-
-describe('CarIndexer fromBytes()', () => {
-  it('complete', async () => {
-    const indexer = await CarIndexer.fromBytes(goCarBytes)
-    await verifyRoots(indexer) // behaves like an Reader for roots
-    assert.strictEqual(indexer.version, 1)
-
-    const indexData = []
-    for await (const index of indexer) {
-      indexData.push(index)
-    }
-
-    assert.deepStrictEqual(indexData, goCarIndex)
-  })
-
-  it('v2 complete', async () => {
-    const indexer = await CarIndexer.fromBytes(goCarV2Bytes)
-    const roots = await indexer.getRoots()
-    assert.strictEqual(roots.length, 1)
-    assert.ok(goCarV2Roots[0].equals(roots[0]))
-    assert.strictEqual(indexer.version, 2)
-
-    const indexData = []
-    for await (const index of indexer) {
-      indexData.push(index)
-    }
-
-    assert.deepStrictEqual(indexData, goCarV2Index)
-  })
-
-  it('bad argument', async () => {
-    for (const arg of [true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
-      // @ts-ignore
-      await assert.isRejected(CarIndexer.fromBytes(arg))
-    }
-  })
-})
-
-describe('CarIndexer fromIterable()', () => {
-  /** @param {CarIndexer} indexer */
-  async function verifyIndexer (indexer) {
-    await verifyRoots(indexer) // behaves like an Reader for roots
-    assert.strictEqual(indexer.version, 1)
-
-    const indexData = []
-    for await (const index of indexer) {
-      indexData.push(index)
-    }
-
-    assert.deepStrictEqual(indexData, goCarIndex)
-  }
-
-  it('complete (single chunk)', async () => {
-    const indexer = await CarIndexer.fromIterable(makeIterable(goCarBytes, goCarBytes.length))
-    return verifyIndexer(indexer)
-  })
-
-  it('complete (101-byte chunks)', async () => {
-    const indexer = await CarIndexer.fromIterable(makeIterable(goCarBytes, 101))
-    return verifyIndexer(indexer)
-  })
-
-  it('complete (32-byte chunks)', async () => {
-    const indexer = await CarIndexer.fromIterable(makeIterable(goCarBytes, 32))
-    return verifyIndexer(indexer)
-  })
-
-  it('bad argument', async () => {
-    for (const arg of [new Uint8Array(0), true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
-      // @ts-ignore
-      await assert.isRejected(CarIndexer.fromIterable(arg))
-    }
-  })
-})

package/test/test-interface.js

@@ -1,24 +0,0 @@
-/* eslint-env mocha */
-import * as car from '@ipld/car'
-import { CarReader, __browser } from '@ipld/car/reader'
-import { CarIndexer } from '@ipld/car/indexer'
-import { CarBlockIterator, CarCIDIterator } from '@ipld/car/iterator'
-import { CarWriter } from '@ipld/car/writer'
-
-import { assert } from './common.js'
-
-// simple sanity check that our main exports match the direct exports
-describe('Interface', () => {
-  it('exports match', () => {
-    assert.strictEqual(car.CarReader, CarReader)
-    assert.strictEqual(car.CarIndexer, CarIndexer)
-    assert.strictEqual(car.CarBlockIterator, CarBlockIterator)
-    assert.strictEqual(car.CarCIDIterator, CarCIDIterator)
-    assert.strictEqual(car.CarWriter, CarWriter)
-  })
-
-  it('browser exports', () => {
-    // @ts-ignore
-    assert.strictEqual(__browser, globalThis.process === undefined)
-  })
-})

package/test/test-iterator.js

@@ -1,74 +0,0 @@
-/* eslint-env mocha */
-
-import { CarBlockIterator, CarCIDIterator } from '@ipld/car/iterator'
-import { carBytes, makeIterable, assert } from './common.js'
-import { verifyRoots, verifyBlocks, verifyCids } from './verify-store-reader.js'
-
-/**
- * @param {CarBlockIterator} iter
- * @returns {Promise<CarBlockIterator>}
- */
-async function verifyBlockIterator (iter) {
-  await verifyRoots(iter)
-  await verifyBlocks(iter)
-  assert.strictEqual(iter.version, 1)
-  return iter
-}
-
-/**
- * @param {CarCIDIterator} iter
- * @returns {Promise<CarCIDIterator>}
- */
-async function verifyCIDIterator (iter) {
-  await verifyRoots(iter)
-  await verifyCids(iter)
-  assert.strictEqual(iter.version, 1)
-  return iter
-}
-
-for (const type of ['Block', 'CID']) {
-  describe(`Car${type}Iterator`, () => {
-    it('fromBytes()', async () => {
-      if (type === 'Block') {
-        await verifyBlockIterator(await CarBlockIterator.fromBytes(carBytes))
-      } else {
-        await verifyCIDIterator(await CarCIDIterator.fromBytes(carBytes))
-      }
-    })
-
-    it('fromBytes() bad double read', async () => {
-      if (type === 'Block') {
-        const iter = await verifyBlockIterator(await CarBlockIterator.fromBytes(carBytes))
-        await assert.isRejected(verifyBlocks(iter), /more than once/i)
-      } else {
-        const iter = await verifyCIDIterator(await CarCIDIterator.fromBytes(carBytes))
-        await assert.isRejected(verifyCids(iter), /more than once/i)
-      }
-    })
-
-    it('fromBytes() bad argument', async () => {
-      for (const arg of [true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
-        // @ts-ignore
-        await assert.isRejected((type === 'Block' ? CarBlockIterator : CarCIDIterator).fromBytes(arg))
-      }
-    })
-
-    it('fromIterable() bad argument', async () => {
-      for (const arg of [new Uint8Array(0), true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
-        // @ts-ignore
-        await assert.isRejected((type === 'Block' ? CarBlockIterator : CarCIDIterator).fromIterable(arg))
-      }
-    })
-
-    for (const chunkSize of [carBytes.length, 100, 64, 32]) {
-      const chunkDesc = chunkSize === carBytes.length ? 'single chunk' : `${chunkSize}  bytes`
-      it(`fromIterable() blocks (${chunkDesc})`, async () => {
-        if (type === 'Block') {
-          await verifyBlockIterator(await CarBlockIterator.fromIterable(makeIterable(carBytes, chunkSize)))
-        } else {
-          await verifyCIDIterator(await CarCIDIterator.fromIterable(makeIterable(carBytes, chunkSize)))
-        }
-      })
-    }
-  })
-}

package/test/test-reader.js

@@ -1,245 +0,0 @@
-/* eslint-env mocha */
-
-import { CarReader } from '@ipld/car/reader'
-import { CarWriter } from '@ipld/car/writer'
-import { bytesReader, readHeader } from '@ipld/car/decoder'
-import * as Block from 'multiformats/block'
-import { sha256 } from 'multiformats/hashes/sha2'
-import * as raw from 'multiformats/codecs/raw'
-import { base64 } from 'multiformats/bases/base64'
-import * as dagPb from '@ipld/dag-pb'
-import {
-  carBytes,
-  makeIterable,
-  assert,
-  goCarV2Bytes,
-  goCarV2Roots,
-  goCarV2Index,
-  goCarV2Contents
-} from './common.js'
-import {
-  verifyRoots,
-  verifyHas,
-  verifyGet,
-  verifyBlocks,
-  verifyCids
-} from './verify-store-reader.js'
-import { data as fixtures } from './fixtures.js'
-import { expectations as fixtureExpectations } from './fixtures-expectations.js'
-
-describe('CarReader fromBytes()', () => {
-  it('complete', async () => {
-    const reader = await CarReader.fromBytes(carBytes)
-    await verifyRoots(reader)
-    await verifyHas(reader)
-    await verifyGet(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-    assert.strictEqual(reader.version, 1)
-  })
-
-  it('complete (get before has) switch', async () => {
-    const reader = await CarReader.fromBytes(carBytes)
-    await verifyRoots(reader)
-    await verifyGet(reader)
-    await verifyHas(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-  })
-
-  it('bad argument', async () => {
-    for (const arg of [true, false, null, undefined, 'string', 100, { obj: 'nope' }]) {
-      // @ts-ignore
-      await assert.isRejected(CarReader.fromBytes(arg))
-    }
-  })
-
-  it('decode error - truncated', async () => {
-    await assert.isRejected(CarReader.fromBytes(carBytes.slice(0, carBytes.length - 10)), {
-      name: 'Error',
-      message: 'Unexpected end of data'
-    })
-  })
-
-  it('v2 complete', async () => {
-    const reader = await CarReader.fromBytes(goCarV2Bytes)
-    const roots = await reader.getRoots()
-    assert.strictEqual(roots.length, 1)
-    assert.ok(goCarV2Roots[0].equals(roots[0]))
-    assert.strictEqual(reader.version, 2)
-    for (const { cid } of goCarV2Index) {
-      const block = await reader.get(cid)
-      assert.isDefined(block)
-      if (block) {
-        assert.ok(cid.equals(block.cid))
-        let content
-        if (cid.code === dagPb.code) {
-          content = dagPb.decode(block.bytes)
-        } else if (cid.code === 85) { // raw
-          content = new TextDecoder().decode(block.bytes)
-        } else {
-          assert.fail('Unexpected codec')
-        }
-        assert.deepStrictEqual(content, goCarV2Contents[cid.toString()])
-      }
-    }
-  })
-
-  it('decode error - trailing null bytes', async () => {
-    const bytes = new Uint8Array(carBytes.length + 5)
-    bytes.set(carBytes)
-    try {
-      await CarReader.fromBytes(bytes)
-    } catch (err) {
-      assert.strictEqual(err.message, 'Invalid CAR section (zero length)')
-      return
-    }
-    assert.fail('Did not throw')
-  })
-
-  it('decode error - bad first byte', async () => {
-    const bytes = new Uint8Array(carBytes.length + 5)
-    bytes.set(carBytes)
-    bytes[0] = 0
-    try {
-      await CarReader.fromBytes(bytes)
-    } catch (err) {
-      assert.strictEqual(err.message, 'Invalid CAR header (zero length)')
-      return
-    }
-    assert.fail('Did not throw')
-  })
-})
-
-describe('CarReader fromIterable()', () => {
-  it('complete (single chunk)', async () => {
-    const reader = await CarReader.fromIterable(makeIterable(carBytes, carBytes.length))
-    await verifyRoots(reader)
-    await verifyHas(reader)
-    await verifyGet(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-  })
-
-  it('complete (101-byte chunks)', async () => {
-    const reader = await CarReader.fromIterable(makeIterable(carBytes, 101))
-    await verifyRoots(reader)
-    await verifyHas(reader)
-    await verifyGet(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-  })
-
-  it('complete (64-byte chunks)', async () => {
-    const reader = await CarReader.fromIterable(makeIterable(carBytes, 64))
-    await verifyRoots(reader)
-    await verifyHas(reader)
-    await verifyGet(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-  })
-
-  it('complete (32-byte chunks)', async () => {
-    const reader = await CarReader.fromIterable(makeIterable(carBytes, 32))
-    await verifyRoots(reader)
-    await verifyHas(reader)
-    await verifyGet(reader)
-    await verifyBlocks(reader.blocks())
-    await verifyCids(reader.cids())
-  })
-
-  it('handle zero-byte chunks', async () => {
-    // write 3 blocks, the middle one has zero bytes - this is a valid dag-pb form
-    // so it's important that we can handle it .. also we may just be dealing with
-    // an asynciterator that provides zero-length chunks
-    const { writer, out } = await CarWriter.create([])
-    const b1 = await Block.encode({ value: Uint8Array.from([0, 1, 2]), hasher: sha256, codec: raw })
-    writer.put(b1)
-    const b2 = await Block.encode({ value: Uint8Array.from([]), hasher: sha256, codec: raw })
-    writer.put(b2)
-    const b3 = await Block.encode({ value: Uint8Array.from([3, 4, 5]), hasher: sha256, codec: raw })
-    writer.put(b3)
-    const closePromise = writer.close()
-    const reader = await CarReader.fromIterable(out) // read from the writer
-    const b1a = await reader.get(b1.cid)
-    assert.isDefined(b1a)
-    assert.deepStrictEqual(b1a && Array.from(b1a.bytes), [0, 1, 2])
-    const b2a = await reader.get(b2.cid)
-    assert.isDefined(b2a)
-    assert.deepStrictEqual(b2a && Array.from(b2a.bytes), [])
-    const b3a = await reader.get(b3.cid)
-    assert.isDefined(b3a)
-    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' }]) {
-      // @ts-ignore
-      await assert.isRejected(CarReader.fromIterable(arg))
-    }
-  })
-
-  it('decode error - truncated', async () => {
-    await assert.isRejected(CarReader.fromIterable(makeIterable(carBytes.slice(0, carBytes.length - 10), 64)), {
-      name: 'Error',
-      message: 'Unexpected end of data'
-    })
-  })
-
-  it('v2 decode error - truncated', async () => {
-    const bytes = goCarV2Bytes.slice()
-    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-    // dataSize is an 64-bit uint at byte offset 35 from the begining, we're shortening it
-    // by 10 to simulate a premature end of CARv1 content
-    dv.setBigUint64(35, BigInt(448 - 10), true)
-    await assert.isRejected(CarReader.fromIterable(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(fixtureExpectations)) {
-      it(name, async () => {
-        const data = base64.baseDecode(fixtures[name])
-        let header
-        try {
-          header = await readHeader(bytesReader(data))
-        } catch (err) {
-          if (expectedError != null) {
-            assert.equal(err.message, expectedError)
-            return
-          }
-          assert.ifError(err)
-        }
-        if (expectedError != null) {
-          assert.fail(`Expected error: ${expectedError}`)
-        }
-        assert.isDefined(header, 'did not decode header')
-        if (expectedVersion != null && header != null) {
-          assert.strictEqual(header.version, expectedVersion)
-        }
-      })
-    }
-  })
-
-  describe('Contents', () => {
-    for (const [name, { cids: expectedCids }] of Object.entries(fixtureExpectations)) {
-      if (expectedCids == null) {
-        continue
-      }
-      it(name, async () => {
-        const data = base64.baseDecode(fixtures[name])
-        const reader = await CarReader.fromBytes(data)
-        let i = 0
-        for await (const cid of reader.cids()) {
-          assert.strictEqual(cid.toString(), expectedCids[i++])
-        }
-        assert.strictEqual(i, expectedCids.length)
-      })
-    }
-  })
-})