test: align size-limit tests with codebase conventions

- decode rejections use assert.isRejected(p, RangeError, 'substring'), matching
  test-errors.spec.js (asserts both type and message in one call)
- encode writer rejections use expect(...).to.eventually.be.rejectedWith(...),
  matching test-writer.spec.js, which avoids the documented case where
  assert.isRejected on a writer.put can throw an uncatchable error in Chrome
- reuse the collector / concatBytes helper shape from test-writer.spec.js
- drop the standalone RangeError tests; the type is now checked inline per cap

Author: tabcat

test/test-decode-limits.spec.js

@@ -42,20 +42,23 @@ async function decodeAll (entry, data, options, chunkSize = 64) {
   return count
 }
 
-/** @param {Uint8Array[]} arrays */
-function concat (...arrays) {
-  const out = new Uint8Array(arrays.reduce((n, a) => n + a.length, 0))
-  let offset = 0
-  for (const a of arrays) {
-    out.set(a, offset)
-    offset += a.length
+/**
+ * @param {Uint8Array[]} chunks
+ */
+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 out
+  return bytes
 }
 
 /** @param {Uint8Array} payload */
 function lengthPrefixed (payload) {
-  return concat(Uint8Array.from(vEncode(payload.length)), payload)
+  return concatBytes([Uint8Array.from(vEncode(payload.length)), payload])
 }
 
 const validV1Header = lengthPrefixed(cbEncode({ version: 1, roots: [] }))
@@ -65,17 +68,17 @@ describe('decode read-size limits', () => {
     for (const entry of ENTRIES) {
       it(`${entry.name}: header larger than maxHeaderLength`, async () => {
         // carBytes' header length prefix declares 99 bytes; cap well below it
-        await assert.isRejected(decodeAll(entry, carBytes, { maxHeaderLength: 10 }), /maxHeaderLength/)
+        await assert.isRejected(decodeAll(entry, carBytes, { maxHeaderLength: 10 }), RangeError, 'maxHeaderLength')
       })
 
       it(`${entry.name}: block larger than maxBlockLength`, async () => {
         // every block in carBytes is at least 4 bytes; cap below that
-        await assert.isRejected(decodeAll(entry, carBytes, { maxBlockLength: 3 }), /maxBlockLength/)
+        await assert.isRejected(decodeAll(entry, carBytes, { maxBlockLength: 3 }), RangeError, 'maxBlockLength')
       })
 
       it(`${entry.name}: CID larger than maxCidLength`, async () => {
         // carBytes' section CIDs are CIDv1 sha2-256 (full CID 36 bytes); cap below that
-        await assert.isRejected(decodeAll(entry, carBytes, { maxCidLength: 10 }), /maxCidLength/)
+        await assert.isRejected(decodeAll(entry, carBytes, { maxCidLength: 10 }), RangeError, 'maxCidLength')
       })
     }
   })
@@ -107,7 +110,7 @@ describe('decode read-size limits', () => {
     // off-by-one that rejects the exactly-equal block fails this test.
     assert.strictEqual(await decodeAll(blockIter, carBytes, { maxBlockLength: max }), total)
     // one below: rejected
-    await assert.isRejected(decodeAll(blockIter, carBytes, { maxBlockLength: max - 1 }), /maxBlockLength/)
+    await assert.isRejected(decodeAll(blockIter, carBytes, { maxBlockLength: max - 1 }), RangeError, 'maxBlockLength')
   })
 
   it('measures the full CID, not just the multihash', async () => {
@@ -124,13 +127,7 @@ describe('decode read-size limits', () => {
     // equal to the full CID: allowed, everything decodes
     assert.ok(await decodeAll(blockIter, carBytes, { maxCidLength: maxCid }) > 0)
     // one below the full CID (still above the 34-byte multihash): rejected
-    await assert.isRejected(decodeAll(blockIter, carBytes, { maxCidLength: maxCid - 1 }), /maxCidLength/)
-  })
-
-  it('size-limit violations reject with a RangeError', async () => {
-    await assert.isRejected(decodeAll(blockIter, carBytes, { maxHeaderLength: 10 }), RangeError)
-    await assert.isRejected(decodeAll(blockIter, carBytes, { maxBlockLength: 3 }), RangeError)
-    await assert.isRejected(decodeAll(blockIter, carBytes, { maxCidLength: 10 }), RangeError)
+    await assert.isRejected(decodeAll(blockIter, carBytes, { maxCidLength: maxCid - 1 }), RangeError, 'maxCidLength')
   })
 
   describe('rejects from the length prefix before buffering the body', () => {
@@ -140,24 +137,24 @@ describe('decode read-size limits', () => {
     const huge = 1_000_000_000
 
     it('header', async () => {
-      const data = concat(Uint8Array.from(vEncode(huge)), Uint8Array.from([1, 2, 3]))
-      await assert.isRejected(decodeAll(blockIter, data, { maxHeaderLength: 1000 }), /maxHeaderLength/)
+      const data = concatBytes([Uint8Array.from(vEncode(huge)), Uint8Array.from([1, 2, 3])])
+      await assert.isRejected(decodeAll(blockIter, data, { maxHeaderLength: 1000 }), RangeError, 'maxHeaderLength')
     })
 
     it('block', async () => {
       const cid = rndCid.bytes
       // declare a section of huge size but supply only the CID, no block body
-      const section = concat(Uint8Array.from(vEncode(huge + cid.length)), cid)
-      const data = concat(validV1Header, section)
-      await assert.isRejected(decodeAll(blockIter, data, { maxBlockLength: 1000 }), /maxBlockLength/)
+      const section = concatBytes([Uint8Array.from(vEncode(huge + cid.length)), cid])
+      const data = concatBytes([validV1Header, section])
+      await assert.isRejected(decodeAll(blockIter, data, { maxBlockLength: 1000 }), RangeError, 'maxBlockLength')
     })
 
     it('CID', async () => {
       // CIDv1, raw codec (0x55), sha2-256 (0x12), huge multihash digest length, no digest
-      const cid = concat(Uint8Array.from([0x01, 0x55, 0x12]), Uint8Array.from(vEncode(huge)))
-      const section = concat(Uint8Array.from(vEncode(cid.length + 1)), cid)
-      const data = concat(validV1Header, section)
-      await assert.isRejected(decodeAll(blockIter, data, { maxCidLength: 1000 }), /maxCidLength/)
+      const cid = concatBytes([Uint8Array.from([0x01, 0x55, 0x12]), Uint8Array.from(vEncode(huge))])
+      const section = concatBytes([Uint8Array.from(vEncode(cid.length + 1)), cid])
+      const data = concatBytes([validV1Header, section])
+      await assert.isRejected(decodeAll(blockIter, data, { maxCidLength: 1000 }), RangeError, 'maxCidLength')
     })
   })
 })

test/test-encode-limits.spec.js

@@ -1,27 +1,37 @@
 /* eslint-env mocha */
 
 import { encode as cbEncode } from '@ipld/dag-cbor'
+import { expect } from 'aegir/chai'
 import { CarReader } from '../src/reader.js'
 import { CarWriter } from '../src/writer.js'
 import { assert, makeData, makeIterable } from './common.js'
 
-/** @param {AsyncIterable<Uint8Array>} iterable */
-async function collect (iterable) {
-  const chunks = []
-  for await (const chunk of iterable) {
-    chunks.push(chunk)
-  }
-  let len = 0
-  for (const c of chunks) {
-    len += c.length
-  }
-  const out = new Uint8Array(len)
+/**
+ * @param {Uint8Array[]} chunks
+ */
+function concatBytes (chunks) {
+  const length = chunks.reduce((p, c) => p + c.length, 0)
+  const bytes = new Uint8Array(length)
   let off = 0
-  for (const c of chunks) {
-    out.set(c, off)
-    off += c.length
+  for (const chunk of chunks) {
+    bytes.set(chunk, off)
+    off += chunk.length
   }
-  return out
+  return bytes
+}
+
+/**
+ * @param {AsyncIterable<Uint8Array>} iterable
+ */
+function collector (iterable) {
+  const chunks = []
+  const cfn = (async () => {
+    for await (const chunk of iterable) {
+      chunks.push(chunk)
+    }
+    return concatBytes(chunks)
+  })()
+  return cfn
 }
 
 /**
@@ -34,7 +44,7 @@ async function collect (iterable) {
  */
 async function writeAll (roots, blocks, options) {
   const { writer, out } = CarWriter.create(roots, options)
-  const collection = collect(out)
+  const collection = collector(out)
   const writes = blocks.map((b) => writer.put(b))
   writes.push(writer.close())
   await Promise.all(writes)
@@ -59,7 +69,7 @@ describe('encode size limits', () => {
   describe('maxHeaderLength', () => {
     it('rejects a header larger than the cap (via first put)', async () => {
       const { writer } = CarWriter.create(roots, { maxHeaderLength: 10 })
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxHeaderLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxHeaderLength/)
     })
 
     it('allows a header exactly equal to the cap, rejects one below', async () => {
@@ -69,7 +79,7 @@ describe('encode size limits', () => {
       assert.ok(bytes.length > 0)
       // one below: rejected from the header
       const { writer } = CarWriter.create(roots, { maxHeaderLength: headerLen - 1 })
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxHeaderLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxHeaderLength/)
     })
   })
 
@@ -80,7 +90,7 @@ describe('encode size limits', () => {
       // pull the single header chunk first to relieve backpressure.
       const { writer, out } = CarWriter.create(roots, { maxBlockLength: 3 })
       await out[Symbol.asyncIterator]().next()
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxBlockLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxBlockLength/)
     })
 
     it('allows a block body exactly equal to the cap', async () => {
@@ -95,7 +105,7 @@ describe('encode size limits', () => {
       // the header chunk so writeBlock (where the CID check lives) runs.
       const { writer, out } = CarWriter.create(roots, { maxCidLength: 10 })
       await out[Symbol.asyncIterator]().next()
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxCidLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxCidLength/)
     })
 
     it('measures the full CID, not the multihash', async () => {
@@ -106,7 +116,7 @@ describe('encode size limits', () => {
       // only rejects if the cap measures the whole CID
       const { writer, out } = CarWriter.create(roots, { maxCidLength: cidLen - 1, maxBlockLength: 1 << 20 })
       await out[Symbol.asyncIterator]().next()
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxCidLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxCidLength/)
     })
 
     it('does NOT reject a CIDv0 CID below the cap (symmetric with decode)', async () => {
@@ -115,27 +125,15 @@ describe('encode size limits', () => {
     })
   })
 
-  it('size-limit violations reject with a RangeError', async () => {
-    // header rejects before any write (no drain needed)
-    await assert.isRejected(CarWriter.create(roots, { maxHeaderLength: 10 }).writer.put(rawBlocks[0]), RangeError)
-    // block and CID reject inside writeBlock, so drain the header chunk first
-    const b = CarWriter.create(roots, { maxBlockLength: 3 })
-    await b.out[Symbol.asyncIterator]().next()
-    await assert.isRejected(b.writer.put(rawBlocks[0]), RangeError)
-    const c = CarWriter.create(roots, { maxCidLength: 10 })
-    await c.out[Symbol.asyncIterator]().next()
-    await assert.isRejected(c.writer.put(rawBlocks[0]), RangeError)
-  })
-
   describe('createAppender', () => {
     it('enforces maxBlockLength on appended blocks', async () => {
       const { writer } = CarWriter.createAppender({ maxBlockLength: 3 })
-      await assert.isRejected(writer.put(rawBlocks[0]), /maxBlockLength/)
+      await expect(writer.put(rawBlocks[0])).to.eventually.be.rejectedWith(RangeError, /maxBlockLength/)
     })
 
     it('writes normally with no caps', async () => {
       const { writer, out } = CarWriter.createAppender()
-      const collection = collect(out)
+      const collection = collector(out)
       await writer.put(rawBlocks[0])
       await writer.close()
       const bytes = await collection