@ipld/car 4.1.6 → 5.0.1

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

@@ -1,85 +0,0 @@
-import { CarIndexer } from '../lib/indexer.js';
-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);
-    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' }
-      ]) {
-      await assert.isRejected(CarIndexer.fromBytes(arg));
-    }
-  });
-});
-describe('CarIndexer fromIterable()', () => {
-  async function verifyIndexer(indexer) {
-    await verifyRoots(indexer);
-    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' }
-      ]) {
-      await assert.isRejected(CarIndexer.fromIterable(arg));
-    }
-  });
-});

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

@@ -1,24 +0,0 @@
-import * as car from '../car.js';
-import {
-  CarReader,
-  __browser
-} from '../lib/reader.js';
-import { CarIndexer } from '../lib/indexer.js';
-import {
-  CarBlockIterator,
-  CarCIDIterator
-} from '../lib/iterator.js';
-import { CarWriter } from '../lib/writer.js';
-import { assert } from './common.js';
-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', () => {
-    assert.strictEqual(__browser, globalThis.process === undefined);
-  });
-});

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

@@ -1,91 +0,0 @@
-import {
-  CarBlockIterator,
-  CarCIDIterator
-} from '../lib/iterator.js';
-import {
-  carBytes,
-  makeIterable,
-  assert
-} from './common.js';
-import {
-  verifyRoots,
-  verifyBlocks,
-  verifyCids
-} from './verify-store-reader.js';
-async function verifyBlockIterator(iter) {
-  await verifyRoots(iter);
-  await verifyBlocks(iter);
-  assert.strictEqual(iter.version, 1);
-  return iter;
-}
-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' }
-        ]) {
-        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' }
-        ]) {
-        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/esm/node-test/test-reader.js

@@ -1,270 +0,0 @@
-import { CarReader } from '../lib/reader.js';
-import { CarWriter } from '../lib/writer.js';
-import {
-  bytesReader,
-  readHeader
-} from '../lib/decoder.js';
-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' }
-      ]) {
-      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) {
-          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 () => {
-    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);
-    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' }
-      ]) {
-      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);
-    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);
-      });
-    }
-  });
-});