@atproto/lex-data 0.1.2 → 0.1.4

package/src/blob.test.ts

@@ -1,405 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  BlobRef,
-  LegacyBlobRef,
-  enumBlobRefs,
-  isLegacyBlobRef,
-  isTypedBlobRef,
-} from './blob.js'
-import { RawCid, parseCid } from './cid.js'
-import { LexArray, LexMap, LexValue } from './lex.js'
-
-// await cidForRawBytes(Buffer.from('Hello, World!'))
-const validBlobCid = parseCid(
-  'bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4',
-  { flavor: 'raw' },
-)
-
-// await cidForLex(Buffer.from('Hello, World!'))
-const invalidBlobCid = parseCid(
-  'bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy',
-  { flavor: 'cbor' },
-)
-
-describe(isTypedBlobRef, () => {
-  it('tests valid blobCid and lexCid', () => {
-    expect(validBlobCid.code).toBe(0x55) // raw
-    expect(validBlobCid.multihash.code).toBe(0x12) // sha2-256
-    expect(invalidBlobCid.code).toBe(0x71) // dag-cbor
-    expect(invalidBlobCid.multihash.code).toBe(0x12) // sha2-256
-  })
-
-  it('parses valid blob', () => {
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: validBlobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-      }),
-    ).toBe(true)
-
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          ref: invalidBlobCid,
-          mimeType: 'image/jpeg',
-          size: 10000,
-        },
-        // In non-strict mode, any CID should be accepted
-        { strict: false },
-      ),
-    ).toBe(true)
-  })
-
-  it('performs strict validation by default', () => {
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: invalidBlobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-      }),
-    ).toBe(false)
-  })
-
-  it('rejects invalid inputs', () => {
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: { $link: validBlobCid.toString() },
-        mimeType: 'image/jpeg',
-        size: '10000',
-      }),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef({
-        // $type: 'blob',
-        ref: validBlobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-      }),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: validBlobCid,
-        mimeType: { toString: () => 'image/jpeg' },
-        size: 10000,
-      }),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          ref: { $link: validBlobCid.toString() },
-          mimeType: 'image/jpeg',
-          size: '10000',
-        },
-        { strict: true },
-      ),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        mimeType: 'image/jpeg',
-        size: 10000,
-      }),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          mimeType: 'image/jpeg',
-          size: 10000,
-        },
-        { strict: true },
-      ),
-    ).toBe(false)
-
-    expect(isTypedBlobRef('not an object')).toBe(false)
-    expect(isTypedBlobRef([])).toBe(false)
-    expect(isTypedBlobRef(new Date())).toBe(false)
-    expect(isTypedBlobRef(new Map())).toBe(false)
-  })
-
-  it('rejects non-integer size', () => {
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: validBlobCid,
-        mimeType: 'image/jpeg',
-        size: 10000.5,
-      }),
-    ).toBe(false)
-  })
-
-  it('rejects invalid CID/multihash code', () => {
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          ref: validBlobCid,
-          mimeType: 'image/jpeg',
-          size: 10000,
-        },
-        { strict: true },
-      ),
-    ).toBe(true)
-
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          ref: invalidBlobCid,
-          mimeType: 'image/jpeg',
-          size: 10000,
-        },
-        { strict: true },
-      ),
-    ).toBe(false)
-  })
-
-  it('rejects extra keys', () => {
-    expect(
-      isTypedBlobRef({
-        $type: 'blob',
-        ref: validBlobCid,
-        mimeType: 'image/jpeg',
-        size: 10000,
-        extra: 'not allowed',
-      }),
-    ).toBe(false)
-
-    expect(
-      isTypedBlobRef(
-        {
-          $type: 'blob',
-          ref: validBlobCid,
-          mimeType: 'image/jpeg',
-          size: 10000,
-          extra: 'not allowed',
-        },
-        { strict: true },
-      ),
-    ).toBe(false)
-  })
-
-  describe('strict mode', () => {
-    it('rejects invalid CID version', () => {
-      const cidV0 = parseCid(
-        'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // CID v0
-      )
-      expect(
-        isTypedBlobRef(
-          {
-            $type: 'blob',
-            ref: cidV0,
-            mimeType: 'image/jpeg',
-            size: 10000,
-          },
-          { strict: true },
-        ),
-      ).toBe(false)
-    })
-  })
-})
-
-describe(isLegacyBlobRef, () => {
-  it('parses valid legacy blob', () => {
-    expect(
-      isLegacyBlobRef({
-        cid: validBlobCid.toString(),
-        mimeType: 'image/jpeg',
-      }),
-    ).toBe(true)
-
-    expect(
-      isLegacyBlobRef(
-        {
-          cid: invalidBlobCid.toString(),
-          mimeType: 'image/jpeg',
-        },
-        { strict: false },
-      ),
-    ).toBe(true)
-  })
-
-  it('rejects invalid inputs', () => {
-    expect(
-      isLegacyBlobRef(
-        {
-          cid: invalidBlobCid.toString(),
-          mimeType: 'image/jpeg',
-        },
-        { strict: true },
-      ),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        cid: 'babbaaa',
-        mimeType: 'image/jpeg',
-      }),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        cid: 12345,
-        mimeType: 'image/jpeg',
-      }),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        mimeType: 'image/jpeg',
-      }),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        cid: invalidBlobCid.toString(),
-        mimeType: { toString: () => 'image/jpeg' },
-      }),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        cid: invalidBlobCid.toString(),
-        mimeType: 3,
-      }),
-    ).toBe(false)
-
-    expect(
-      isLegacyBlobRef({
-        cid: invalidBlobCid.toString(),
-        mimeType: '',
-      }),
-    ).toBe(false)
-
-    expect(isLegacyBlobRef([])).toBe(false)
-    expect(isLegacyBlobRef('not an object')).toBe(false)
-    expect(isLegacyBlobRef(new Date())).toBe(false)
-    expect(isLegacyBlobRef(new Map())).toBe(false)
-  })
-
-  it('rejects extra keys', () => {
-    expect(
-      isLegacyBlobRef({
-        cid: validBlobCid.toString(),
-        mimeType: 'image/jpeg',
-        extra: 'not allowed',
-      }),
-    ).toBe(false)
-  })
-})
-
-describe(enumBlobRefs, () => {
-  const valid1: BlobRef<RawCid> = {
-    $type: 'blob',
-    ref: validBlobCid,
-    mimeType: 'image/png',
-    size: 2048,
-  }
-
-  const valid2: BlobRef<RawCid> = {
-    $type: 'blob',
-    ref: validBlobCid,
-    mimeType: 'image/jpeg',
-    size: 1024,
-  }
-
-  const invalid: BlobRef = {
-    $type: 'blob',
-    ref: invalidBlobCid,
-    mimeType: 'image/jpeg',
-    size: 1024,
-  }
-
-  const legacy: LegacyBlobRef = {
-    cid: validBlobCid.toString(),
-    mimeType: 'image/gif',
-  }
-
-  const data: LexValue = {
-    name: 'example',
-    file: { deeply: { nested: { in: { object: { valid1 } } } } },
-    attachments: [valid2, invalid, legacy, { description: 'not a blob' }],
-  }
-
-  it('enumerates valid BlobRefs by default', () => {
-    const refs = Array.from(enumBlobRefs(data))
-    expect(refs).toHaveLength(2)
-    expect(refs.includes(valid1)).toBe(true)
-    expect(refs.includes(valid2)).toBe(true)
-  })
-
-  describe('strict support', () => {
-    it('enumerates valid BlobRefs in strict mode', () => {
-      const refs = Array.from(enumBlobRefs(data, { strict: true }))
-      expect(refs).toHaveLength(2)
-      expect(refs.includes(valid1)).toBe(true)
-      expect(refs.includes(valid2)).toBe(true)
-    })
-
-    it('enumerates all BlobRefs in non-strict mode', () => {
-      const refs = Array.from(enumBlobRefs(data, { strict: false }))
-      expect(refs).toHaveLength(3)
-      expect(refs.includes(valid1)).toBe(true)
-      expect(refs.includes(valid2)).toBe(true)
-      expect(refs.includes(invalid)).toBe(true)
-    })
-  })
-
-  describe('legacy support', () => {
-    it('returns LegacyBlobRefs when legacy option is enabled', () => {
-      const refs = Array.from(enumBlobRefs(data, { allowLegacy: true }))
-      expect(refs).toHaveLength(3)
-      expect(refs.includes(valid1)).toBe(true)
-      expect(refs.includes(valid2)).toBe(true)
-      expect(refs.includes(legacy)).toBe(true)
-    })
-  })
-
-  describe('safety', () => {
-    it('handles cyclic structures without infinite loops', () => {
-      const cyclicArray: LexArray = [valid2]
-      const cyclicObject: LexMap = {
-        name: 'cyclic',
-        blob: valid1,
-      }
-
-      // Creating a cycle
-      cyclicArray.push(cyclicArray)
-      cyclicObject.self = cyclicObject
-
-      const refs = Array.from(
-        enumBlobRefs({
-          cyclicObject,
-          cyclicArray,
-        }),
-      )
-      expect(refs).toHaveLength(2)
-      expect(refs.includes(valid1)).toBe(true)
-      expect(refs.includes(valid2)).toBe(true)
-    })
-
-    it('handles deep structures without exceeding call stack', () => {
-      // Creating a deep nested structure
-      let deepData: LexMap = { blob: valid1 }
-      for (let i = 0; i < 100_000; i++) {
-        deepData = { nested: deepData }
-      }
-
-      const refs = Array.from(enumBlobRefs(deepData))
-      expect(refs).toHaveLength(1)
-      expect(refs[0]).toBe(valid1)
-    })
-  })
-})