@atproto/lex-data 0.0.6 → 0.0.8

package/src/cid.test.ts

@@ -1,29 +1,56 @@
+/* eslint-disable import/no-deprecated */
+
 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 {
-  RAW_BIN_MULTICODEC,
-  createCid,
+  Cid,
+  DAG_CBOR_MULTICODEC,
+  RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  asMultiformatsCID,
+  cidForRawHash,
   decodeCid,
   ensureValidCidString,
   isCid,
   parseCid,
-  parseCidString,
+  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 rawCidCustom: Cid = createCustomCid(
+  1,
+  RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  rawCid.multihash.digest,
+)
+const rawCidCustomBytes = new BytesCid(rawCid.bytes)
 
 describe(isCid, () => {
   describe('non-strict mode', () => {
     it('returns true for parsed CIDs', () => {
-      const cid = parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      )
-      expect(isCid(cid)).toBe(true)
+      expect(isCid(cborCid)).toBe(true)
+      expect(isCid(rawCid)).toBe(true)
+    })
+
+    it('returns true for custom compatible CID implementations', () => {
+      expect(isCid(rawCidCustom)).toBe(true)
+      expect(isCid(rawCidCustomBytes)).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_BIN_MULTICODEC, digest)
+      const cidV1 = CID.createV1(RAW_MULTICODEC, digest)
       expect(isCid(cidV0)).toBe(true)
       expect(isCid(cidV1)).toBe(true)
     })
@@ -35,92 +62,184 @@ describe(isCid, () => {
     })
   })
 
-  describe('strict mode', () => {
-    it('returns true for valid CIDs in strict mode', async () => {
-      const digest = await sha256.digest(Buffer.from('hello world'))
-      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
-      expect(isCid(cid, { strict: true })).toBe(true)
+  describe('flavors', () => {
+    describe('raw', () => {
+      it('validated "raw" cids', async () => {
+        const digest = await sha256.digest(Buffer.from('hello world'))
+        const cid = CID.createV1(RAW_MULTICODEC, 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_MULTICODEC, 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)
+      })
     })
 
-    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, { strict: true })).toBe(false)
+    describe('cbor', () => {
+      it('validated "cbor" cids', async () => {
+        const digest = await sha256.digest(Buffer.from('hello world'))
+        const cid = CID.createV1(DAG_CBOR_MULTICODEC, 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_MULTICODEC, 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)
+      })
     })
+  })
 
-    it('rejects CIDs with invalid hash algorithm', async () => {
-      const digest = await sha512.digest(Buffer.from('hello world'))
-      const cid = CID.createV1(RAW_BIN_MULTICODEC, digest)
-      expect(isCid(cid, { strict: true })).toBe(false)
+  describe('alternative cid implementations', () => {
+    it('accepts compatible CID implementations', () => {
+      expect(isCid(rawCidCustom)).toBe(true)
     })
 
-    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, { strict: true })).toBe(false)
+    it('rejects non-matching version', () => {
+      expect(isCid({ ...rawCidCustom, version: 0 })).toBe(false)
     })
-  })
-})
 
-describe(createCid, () => {
-  it('creates a valid CID v1', async () => {
-    const digest = await sha256.digest(Buffer.from('hello world'))
-    const cid = createCid(RAW_BIN_MULTICODEC, digest)
-    expect(cid.version).toBe(1)
-    expect(cid.code).toBe(RAW_BIN_MULTICODEC)
-    expect(cid.multihash.code).toBe(sha256.code)
-    expect(cid.multihash.digest).toEqual(digest.digest)
+    it('rejects non-matching code', () => {
+      expect(isCid({ ...rawCidCustom, code: 0 })).toBe(false)
+    })
+
+    it('rejects non-matching multihash code', () => {
+      expect(
+        isCid({
+          ...rawCidCustom,
+          multihash: { ...rawCidCustom.multihash, code: 0 },
+        }),
+      ).toBe(false)
+    })
+
+    it('rejects non-matching multihash digest', () => {
+      const differentDigest = new Uint8Array(32)
+      differentDigest[0] = 1
+      expect(
+        isCid({
+          ...rawCidCustom,
+          multihash: { ...rawCidCustom.multihash, digest: differentDigest },
+        }),
+      ).toBe(false)
+    })
+
+    it('rejects objects without equals method', () => {
+      expect(isCid({ ...rawCidCustom, equals: undefined })).toBe(false)
+    })
+
+    it('rejects object with throwing equals method', () => {
+      expect(
+        isCid({
+          ...rawCidCustom,
+          equals: () => {
+            throw new Error('fail')
+          },
+        }),
+      ).toBe(false)
+    })
   })
 })
 
 describe(decodeCid, () => {
   it('decodes CID from bytes', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
+    const cid = parseCid(cborCidStr)
     const bytes = cid.bytes
     const decodedCid = decodeCid(bytes)
-    expect(decodedCid.toString()).toBe(cidStr)
+    expect(decodedCid.toString()).toBe(cborCidStr)
   })
 })
 
 describe(parseCid, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
-    expect(cid.toString()).toBe(cidStr)
+    expect(parseCid(cborCidStr).toString()).toBe(cborCidStr)
+    expect(parseCid(rawCidStr).toString()).toBe(rawCidStr)
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     expect(() => parseCid(invalidCidStr)).toThrow()
   })
 })
 
-describe(parseCidString, () => {
+describe(parseCidSafe, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCidString(cidStr)
-    expect(cid).toBeDefined()
-    expect(cid!.toString()).toBe(cidStr)
+    expect(parseCidSafe(cborCidStr)?.toString()).toBe(cborCidStr)
+    expect(parseCidSafe(rawCidStr)?.toString()).toBe(rawCidStr)
   })
 
   it('returns undefined for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
-    const cid = parseCidString(invalidCidStr)
-    expect(cid).toBeUndefined()
+    expect(parseCidSafe(invalidCidStr)).toBeNull()
   })
 })
 
 describe(ensureValidCidString, () => {
   it('does not throw for valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    expect(() => ensureValidCidString(cidStr)).not.toThrow()
+    expect(() => ensureValidCidString(cborCidStr)).not.toThrow()
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     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_MULTICODEC)
+    expect(cid.multihash.code).toBe(SHA256_MULTIHASH)
+    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, rawCidCustom, rawCidCustomBytes]) {
+      expect(asMultiformatsCID(cid)).toBeInstanceOf(CID)
+      expect(asMultiformatsCID(cid)).toMatchObject({
+        version: cid.version,
+        code: cid.code,
+        multihash: {
+          code: cid.multihash.code,
+          digest: cid.multihash.digest,
+        },
+      })
+    }
+  })
+})