@atproto/lex-data 0.1.3 → 0.1.4

package/src/cid.test.ts

@@ -1,350 +0,0 @@
-import { CID } from 'multiformats/cid'
-import { sha256, sha512 } from 'multiformats/hashes/sha2'
-import { describe, expect, it } from 'vitest'
-import { BytesCid, createCustomCid } from './cid-implementation.test.js'
-import {
-  CBOR_DATA_CODEC,
-  Cid,
-  RAW_DATA_CODEC,
-  SHA256_HASH_CODE,
-  asMultiformatsCID,
-  cidForRawHash,
-  decodeCid,
-  ensureValidCidString,
-  isCid,
-  isCidForBytes,
-  parseCid,
-  parseCidSafe,
-} from './cid.js'
-import { ui8Equals } from './uint8array.js'
-
-const invalidCidStr = 'invalidcidstring'
-
-const cborCidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-const cborCid = parseCid(cborCidStr, { flavor: 'cbor' })
-
-const rawCidStr = 'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4'
-const rawCid = parseCid(rawCidStr, { flavor: 'raw' })
-
-const rawCidLike: Cid = createCustomCid(
-  1,
-  RAW_DATA_CODEC,
-  SHA256_HASH_CODE,
-  rawCid.multihash.digest,
-)
-const rawBytesCid = new BytesCid(rawCid.bytes)
-
-describe(isCid, () => {
-  describe('non-strict mode', () => {
-    it('returns true for parsed CIDs', () => {
-      expect(isCid(cborCid)).toBe(true)
-      expect(isCid(rawCid)).toBe(true)
-    })
-
-    it('returns true for custom compatible CID implementations', () => {
-      expect(isCid(rawCidLike)).toBe(true)
-      expect(isCid(rawBytesCid)).toBe(true)
-    })
-
-    it('returns true for CID v0 and v1', async () => {
-      const digest = await sha256.digest(Buffer.from('hello world'))
-      const cidV0 = CID.createV0(digest)
-      const cidV1 = CID.createV1(RAW_DATA_CODEC, digest)
-      expect(isCid(cidV0)).toBe(true)
-      expect(isCid(cidV1)).toBe(true)
-    })
-
-    it('returns false for invalid CIDs', () => {
-      expect(isCid(new Date())).toBe(false)
-      expect(isCid({})).toBe(false)
-      expect(isCid('not a cid')).toBe(false)
-    })
-  })
-
-  describe('flavors', () => {
-    describe('raw', () => {
-      it('validated "raw" cids', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(RAW_DATA_CODEC, digest)
-        expect(isCid(cid, { flavor: 'raw' })).toBe(true)
-      })
-
-      it('allows other hash algorithms', async () => {
-        const digest = await sha512.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(RAW_DATA_CODEC, digest)
-        expect(isCid(cid, { flavor: 'raw' })).toBe(true)
-      })
-
-      it('rejects CID v0 when strict option is set', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV0(digest)
-        expect(isCid(cid, { flavor: 'raw' })).toBe(false)
-      })
-
-      it('rejects CIDs with invalid code', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(3333, digest)
-        expect(isCid(cid, { flavor: 'raw' })).toBe(false)
-      })
-    })
-
-    describe('cbor', () => {
-      it('validated "cbor" cids', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(CBOR_DATA_CODEC, digest)
-        expect(isCid(cid, { flavor: 'cbor' })).toBe(true)
-      })
-
-      it('rejects CIDs with invalid hash algorithm', async () => {
-        const digest = await sha512.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(RAW_DATA_CODEC, digest)
-        expect(isCid(cid, { flavor: 'cbor' })).toBe(false)
-      })
-
-      it('rejects CID v0 when strict option is set', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV0(digest)
-        expect(isCid(cid, { flavor: 'cbor' })).toBe(false)
-      })
-
-      it('rejects CIDs with invalid code', async () => {
-        const digest = await sha256.digest(Buffer.from('hello world'))
-        const cid = CID.createV1(3333, digest)
-        expect(isCid(cid, { flavor: 'cbor' })).toBe(false)
-      })
-    })
-  })
-
-  describe('alternative cid implementations', () => {
-    it('accepts compatible CID implementations', () => {
-      expect(isCid(rawCidLike)).toBe(true)
-    })
-
-    it('rejects non-matching version', () => {
-      expect(isCid({ ...rawCidLike, version: 0 })).toBe(false)
-    })
-
-    it('rejects non-matching code', () => {
-      expect(isCid({ ...rawCidLike, code: -1 })).toBe(false)
-      expect(isCid({ ...rawCidLike, code: 0 })).toBe(false)
-      expect(isCid({ ...rawCidLike, code: 256 })).toBe(false)
-    })
-
-    it('rejects invalid bytes property', () => {
-      expect(isCid({ ...rawCidLike, bytes: undefined })).toBe(false)
-      expect(isCid({ ...rawCidLike, bytes: 12 })).toBe(false)
-      expect(isCid({ ...rawCidLike, bytes: {} })).toBe(false)
-      expect(isCid({ ...rawCidLike, bytes: [] })).toBe(false)
-
-      expect(
-        isCid({
-          ...rawCidLike,
-          bytes: rawCidLike.bytes.subarray(0, rawCidLike.bytes.length - 1),
-        }),
-      ).toBe(false)
-
-      const bytes = new Uint8Array(rawCidLike.bytes.length)
-
-      bytes.set(rawCidLike.bytes)
-      expect(isCid({ ...rawCidLike, bytes })).toBe(true)
-
-      bytes[0] = bytes[0] ^ 0xff
-      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
-      bytes.set(rawCidLike.bytes)
-
-      bytes[3] = bytes[3] ^ 0xff
-      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
-      bytes.set(rawCidLike.bytes)
-
-      bytes[6] = bytes[6] ^ 0xff
-      expect(isCid({ ...rawCidLike, bytes })).toBe(false)
-      bytes.set(rawCidLike.bytes)
-    })
-
-    describe('multihash property', () => {
-      it('rejects non-matching object', () => {
-        expect(isCid({ ...rawCidLike, multihash: undefined })).toBe(false)
-        expect(isCid({ ...rawCidLike, multihash: 12 })).toBe(false)
-        expect(isCid({ ...rawCidLike, multihash: {} })).toBe(false)
-        expect(isCid({ ...rawCidLike, multihash: [] })).toBe(false)
-      })
-
-      it('rejects non-matching code', () => {
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, code: -1 },
-          }),
-        ).toBe(false)
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, code: 0 },
-          }),
-        ).toBe(false)
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, code: 256 },
-          }),
-        ).toBe(false)
-      })
-
-      it('rejects non Uint8Array digest', () => {
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
-          }),
-        ).toBe(false)
-      })
-
-      it('rejects non Uint8Array digest', () => {
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, digest: new Array(32) },
-          }),
-        ).toBe(false)
-      })
-
-      it('rejects non-matching digest', () => {
-        const differentDigest = new Uint8Array(32)
-        differentDigest[0] = 1
-        expect(
-          isCid({
-            ...rawCidLike,
-            multihash: { ...rawCidLike.multihash, digest: differentDigest },
-          }),
-        ).toBe(false)
-      })
-    })
-
-    describe('equals() method', () => {
-      it('rejects objects without equals method', () => {
-        expect(isCid({ ...rawCidLike, equals: undefined })).toBe(false)
-        expect(isCid({ ...rawCidLike, equals: () => false })).toBe(false)
-      })
-
-      it('rejects object with throwing equals method', () => {
-        expect(
-          isCid({
-            ...rawCidLike,
-            equals: () => {
-              throw new Error('fail')
-            },
-          }),
-        ).toBe(false)
-      })
-    })
-  })
-})
-
-describe(decodeCid, () => {
-  it('decodes CID from bytes', () => {
-    const cid = parseCid(cborCidStr)
-    const bytes = cid.bytes
-    const decodedCid = decodeCid(bytes)
-    expect(decodedCid.toString()).toBe(cborCidStr)
-  })
-})
-
-describe(parseCid, () => {
-  it('parses valid CIDs', () => {
-    expect(parseCid(cborCidStr).toString()).toBe(cborCidStr)
-    expect(parseCid(rawCidStr).toString()).toBe(rawCidStr)
-  })
-
-  it('throws for invalid CIDs', () => {
-    expect(() => parseCid(invalidCidStr)).toThrow()
-  })
-})
-
-describe(isCidForBytes, () => {
-  describe('raw', () => {
-    it('returns true for valid raw CID bytes', async () => {
-      for (const hasher of [sha256, sha512]) {
-        const data = new TextEncoder().encode('hello world')
-        const digest = await hasher.digest(data)
-        const cid = CID.createV1(RAW_DATA_CODEC, digest)
-        expect(await isCidForBytes(cid, data)).toBe(true)
-
-        data[0] = data[0] ^ 0xff
-        expect(await isCidForBytes(cid, data)).toBe(false)
-      }
-    })
-  })
-
-  describe('cbor', () => {
-    it('returns true for valid cbor CID bytes', async () => {
-      for (const hasher of [sha256, sha512]) {
-        // @NOTE this is not valid CBOR, but sufficient for testing the hash
-        const data = new TextEncoder().encode('hello world')
-        const digest = await hasher.digest(data)
-        const cid = CID.createV1(CBOR_DATA_CODEC, digest)
-        expect(await isCidForBytes(cid, data)).toBe(true)
-
-        data[0] = data[0] ^ 0xff
-        expect(await isCidForBytes(cid, data)).toBe(false)
-      }
-    })
-  })
-})
-
-describe(parseCidSafe, () => {
-  it('parses valid CIDs', () => {
-    expect(parseCidSafe(cborCidStr)?.toString()).toBe(cborCidStr)
-    expect(parseCidSafe(rawCidStr)?.toString()).toBe(rawCidStr)
-  })
-
-  it('returns undefined for invalid CIDs', () => {
-    expect(parseCidSafe(invalidCidStr)).toBeNull()
-  })
-})
-
-describe(ensureValidCidString, () => {
-  it('does not throw for valid CIDs', () => {
-    expect(() => ensureValidCidString(cborCidStr)).not.toThrow()
-  })
-
-  it('throws for invalid CIDs', () => {
-    expect(() => ensureValidCidString(invalidCidStr)).toThrow(
-      'Invalid CID string',
-    )
-  })
-})
-
-describe(cidForRawHash, () => {
-  it('creates a RawCid from a SHA-256 hash', () => {
-    const hash = new Uint8Array(32)
-    const cid = cidForRawHash(hash)
-    expect(cid.code).toBe(RAW_DATA_CODEC)
-    expect(cid.multihash.code).toBe(SHA256_HASH_CODE)
-    expect(ui8Equals(cid.multihash.digest, hash)).toBe(true)
-  })
-
-  it('rejects hashes on invalid lengths', () => {
-    expect(() => cidForRawHash(new Uint8Array(31))).toThrow(
-      'Invalid SHA-256 hash length',
-    )
-    expect(() => cidForRawHash(new Uint8Array(33))).toThrow(
-      'Invalid SHA-256 hash length',
-    )
-  })
-})
-
-describe(asMultiformatsCID, () => {
-  it('converts compatible CID to multiformats CID', () => {
-    for (const cid of [cborCid, rawCid, rawCidLike, rawBytesCid]) {
-      expect(asMultiformatsCID(cid)).toBeInstanceOf(CID)
-      expect(asMultiformatsCID(cid)).toMatchObject({
-        version: cid.version,
-        code: cid.code,
-        multihash: {
-          code: cid.multihash.code,
-          digest: cid.multihash.digest,
-        },
-      })
-    }
-  })
-})