@marcuspuchalla/nachos 0.1.0

package/src/parser/__tests__/cbor-tag-errors.test.ts

@@ -0,0 +1,447 @@
+/**
+ * CBOR Tag Parser Error Handling Tests
+ * Tests all error cases and edge cases for 100% code coverage
+ */
+
+import { describe, it, expect } from 'vitest'
+import { useCborTag } from '../composables/useCborTag'
+
+describe('useCborTag - Error Handling', () => {
+  describe('parseItem - Unexpected End of Buffer', () => {
+    it('should throw error when buffer ends before tagged value', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with no value following
+      expect(() => parseTag('c0')).toThrow('Unexpected end of buffer after tag 0')
+    })
+
+    it('should throw error when nested structure is incomplete', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with array that's incomplete
+      // c1 (tag 1) + 82 (array of 2) + 01 (element 1) - missing element 2
+      expect(() => parseTag('c18201')).toThrow('Unexpected end of buffer at offset')
+    })
+  })
+
+  describe('parseItem - Unknown Major Type', () => {
+    it('should never have unknown major type (defensive check)', () => {
+      const { parseTag } = useCborTag()
+
+      // All major types 0-7 should be handled correctly in tagged values
+      // MT 0-7 are all valid, so this defensive code path is hard to trigger
+      // without mocking, but the code exists for safety
+
+      // Test that all major types work correctly when tagged
+      expect(() => parseTag('c000')).not.toThrow() // Tag(0)
+      expect(() => parseTag('c020')).not.toThrow() // Tag(-1)
+      expect(() => parseTag('c040')).not.toThrow() // Tag(h'')
+      expect(() => parseTag('c060')).not.toThrow() // Tag("")
+      expect(() => parseTag('c080')).not.toThrow() // Tag([])
+      expect(() => parseTag('c0a0')).not.toThrow() // Tag({})
+      expect(() => parseTag('c0c000')).not.toThrow() // Tag(Tag(0))
+      expect(() => parseTag('c0f4')).not.toThrow() // Tag(false)
+    })
+  })
+
+  describe('parseItem - Simple Values in Tags', () => {
+    it('should parse tag with boolean values', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with false
+      const result1 = parseTag('c0f4')
+      expect(result1.value).toEqual({ tag: 0, value: false })
+
+      // Tag with true
+      const result2 = parseTag('c0f5')
+      expect(result2.value).toEqual({ tag: 0, value: true })
+    })
+
+    it('should parse tag with null', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with null
+      const result = parseTag('c0f6')
+      expect(result.value).toEqual({ tag: 0, value: null })
+    })
+
+    it('should parse tag with undefined', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with undefined
+      const result = parseTag('c0f7')
+      expect(result.value).toEqual({ tag: 0, value: undefined })
+    })
+
+    it('should parse tag with unassigned simple values', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with simple(16)
+      const result = parseTag('c0f0')
+      expect(result.value).toEqual({ tag: 0, value: { simpleValue: 16 } })
+    })
+  })
+
+  describe('parseArrayInternal - Wrong Major Type', () => {
+    it('should throw error when expecting array but gets integer', () => {
+      const { parseTag } = useCborTag()
+
+      // This is hard to trigger directly, but we can test by ensuring
+      // arrays in tagged values work correctly
+      // Tag 0 with array should work
+      expect(() => parseTag('c080')).not.toThrow()
+    })
+  })
+
+  describe('parseArrayInternal - All Length Encodings', () => {
+    it('should parse tag with 1-byte array length (AI 24)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array of 24 elements (AI 24)
+      // c0 (tag 0) + 9818 (array, 24 elements, 1-byte length) + 24x 00
+      const result = parseTag('c09818' + '00'.repeat(24))
+      expect(result.value.value).toHaveLength(24)
+    })
+
+    it('should parse tag with 2-byte array length (AI 25)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array of 256 elements (AI 25)
+      // c0 (tag 0) + 990100 (array, 256 elements, 2-byte length) + 256x 00
+      const result = parseTag('c0990100' + '00'.repeat(256))
+      expect(result.value.value).toHaveLength(256)
+    })
+
+    it('should parse tag with 4-byte array length (AI 26)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array of 1000 elements (AI 26)
+      // c0 (tag 0) + 9a000003e8 (array, 1000 elements, 4-byte length) + 1000x 00
+      const result = parseTag('c09a000003e8' + '00'.repeat(1000))
+      expect(result.value.value).toHaveLength(1000)
+    })
+
+    it('should parse tag with 8-byte array length (AI 27)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array of 100 elements (AI 27, 8-byte length)
+      // c0 (tag 0) + 9b0000000000000064 (array, 100 elements, 8-byte length) + 100x 00
+      const result = parseTag('c09b0000000000000064' + '00'.repeat(100))
+      expect(result.value.value).toHaveLength(100)
+    })
+
+    it('should throw error for reserved AI 28 in array', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array using reserved AI 28
+      // c0 (tag 0) + 9c (array, AI 28 - reserved)
+      expect(() => parseTag('c09c')).toThrow('Invalid additional info for array: 28')
+    })
+
+    it('should throw error for reserved AI 29 in array', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array using reserved AI 29
+      expect(() => parseTag('c09d')).toThrow('Invalid additional info for array: 29')
+    })
+
+    it('should throw error for reserved AI 30 in array', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with array using reserved AI 30
+      expect(() => parseTag('c09e')).toThrow('Invalid additional info for array: 30')
+    })
+  })
+
+  describe('parseArrayInternal - Indefinite Length', () => {
+    it('should parse tag with indefinite-length array', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with indefinite array [_ 1, 2, 3]
+      // c0 (tag 0) + 9f (indefinite array) + 01 02 03 + ff (break)
+      const result = parseTag('c09f010203ff')
+      expect(Array.isArray(result.value.value)).toBe(true)
+      const arr = result.value.value as any[]
+      expect(arr[0]).toBe(1)
+      expect(arr[1]).toBe(2)
+      expect(arr[2]).toBe(3)
+    })
+
+    it('should parse tag with empty indefinite array', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with empty indefinite array
+      // c0 (tag 0) + 9f (indefinite array) + ff (break)
+      const result = parseTag('c09fff')
+      expect(Array.isArray(result.value.value)).toBe(true)
+      expect(result.value.value).toHaveLength(0)
+    })
+
+    it('should parse nested indefinite arrays in tag', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with nested indefinite arrays
+      // c0 (tag 0) + 9f (indefinite) + 9f 01 ff (nested [_ 1]) + ff (break)
+      const result = parseTag('c09f9f01ffff')
+      expect(Array.isArray(result.value.value)).toBe(true)
+      const arr = result.value.value as any[]
+      expect(arr).toHaveLength(1)
+      expect(Array.isArray(arr[0])).toBe(true)
+      expect(arr[0][0]).toBe(1)
+    })
+  })
+
+  describe('parseMapInternal - Wrong Major Type', () => {
+    it('should parse tag with map correctly', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map
+      expect(() => parseTag('c0a0')).not.toThrow()
+    })
+  })
+
+  describe('parseMapInternal - All Length Encodings', () => {
+    it('should parse tag with 1-byte map length (AI 24)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map of 24 entries (AI 24)
+      // c0 (tag 0) + b818 (map, 24 entries, 1-byte length) + 24x unique key-value pairs
+      // Use keys 0-23 which are safe (direct encoding, no reserved values)
+      const entries = Array.from({ length: 24 }, (_, i) => {
+        // Use keys 0-23, values 0-23 (but different from key)
+        const key = i.toString(16).padStart(2, '0')
+        const value = ((i + 1) % 24).toString(16).padStart(2, '0')
+        return key + value
+      }).join('')
+      const result = parseTag('c0b818' + entries)
+      // Should have 24 entries (keys 0-23 are unique)
+      expect(result.value.value.size).toBe(24)
+    })
+
+    it('should parse tag with 2-byte map length (AI 25)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map of 100 entries (AI 25)
+      // c0 (tag 0) + b90064 (map, 100 entries, 2-byte length) + 100x unique key-value pairs
+      // Use 1-byte length encoding for keys to avoid reserved AI values
+      const entries = Array.from({ length: 100 }, (_, i) => {
+        // Use AI 24 encoding: 1818 for value 24, 1819 for 25, etc.
+        const keyHex = '18' + (24 + i).toString(16).padStart(2, '0')
+        const valueHex = '18' + (124 + i).toString(16).padStart(2, '0')
+        return keyHex + valueHex
+      }).join('')
+      const result = parseTag('c0b90064' + entries)
+      expect(result.value.value.size).toBe(100)
+    })
+
+    it('should parse tag with 4-byte map length (AI 26)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map of 50 entries (AI 26, 4-byte length)
+      // c0 (tag 0) + ba00000032 (map, 50 entries, 4-byte length) + 50x unique key-value pairs
+      const entries = Array.from({ length: 50 }, (_, i) => {
+        const keyHex = '18' + (30 + i).toString(16).padStart(2, '0')
+        const valueHex = '18' + (80 + i).toString(16).padStart(2, '0')
+        return keyHex + valueHex
+      }).join('')
+      const result = parseTag('c0ba00000032' + entries)
+      expect(result.value.value.size).toBe(50)
+    })
+
+    it('should parse tag with 8-byte map length (AI 27)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map of 30 entries (AI 27, 8-byte length)
+      // c0 (tag 0) + bb000000000000001e (map, 30 entries, 8-byte length) + 30x unique key-value pairs
+      const entries = Array.from({ length: 30 }, (_, i) => {
+        const keyHex = '18' + (40 + i).toString(16).padStart(2, '0')
+        const valueHex = '18' + (70 + i).toString(16).padStart(2, '0')
+        return keyHex + valueHex
+      }).join('')
+      const result = parseTag('c0bb000000000000001e' + entries)
+      expect(result.value.value.size).toBe(30)
+    })
+
+    it('should throw error for reserved AI 28 in map', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map using reserved AI 28
+      // c0 (tag 0) + bc (map, AI 28 - reserved)
+      expect(() => parseTag('c0bc')).toThrow('Invalid additional info for map: 28')
+    })
+
+    it('should throw error for reserved AI 29 in map', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map using reserved AI 29
+      expect(() => parseTag('c0bd')).toThrow('Invalid additional info for map: 29')
+    })
+
+    it('should throw error for reserved AI 30 in map', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with map using reserved AI 30
+      expect(() => parseTag('c0be')).toThrow('Invalid additional info for map: 30')
+    })
+  })
+
+  describe('parseMapInternal - Indefinite Length', () => {
+    it('should parse tag with indefinite-length map', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with indefinite map {_ 1: 2, 3: 4}
+      // c0 (tag 0) + bf (indefinite map) + 01 02 03 04 + ff (break)
+      const result = parseTag('c0bf01020304ff')
+      expect(result.value.value).toEqual(new Map([[1, 2], [3, 4]]))
+    })
+
+    it('should parse tag with empty indefinite map', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with empty indefinite map
+      // c0 (tag 0) + bf (indefinite map) + ff (break)
+      const result = parseTag('c0bfff')
+      expect(result.value.value).toEqual(new Map())
+    })
+
+    it('should parse nested indefinite maps in tag', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 with nested indefinite map
+      // c0 (tag 0) + bf (indefinite) + 01 (key) + bf 02 03 ff (nested map) + ff (break)
+      const result = parseTag('c0bf01bf0203ffff')
+      expect(result.value.value).toEqual(new Map([[1, new Map([[2, 3]])]]))
+    })
+  })
+
+  describe('parseTagNumber - Large Tag Numbers', () => {
+    it('should parse tag with 1-byte number (AI 24)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 255 (largest 1-byte tag)
+      // d8ff (tag 255) + 00 (value)
+      const result = parseTag('d8ff00')
+      expect(result.value.tag).toBe(255)
+    })
+
+    it('should parse tag with 2-byte number (AI 25)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 256 (smallest 2-byte tag)
+      // d90100 (tag 256) + 00 (value)
+      const result = parseTag('d9010000')
+      expect(result.value.tag).toBe(256)
+    })
+
+    it('should parse tag with 4-byte number (AI 26)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 70000 (requires 4 bytes)
+      // da00011170 (tag 70000) + 00 (value)
+      const result = parseTag('da0001117000')
+      expect(result.value.tag).toBe(70000)
+    })
+
+    it('should parse tag with 8-byte number (AI 27)', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag with 8-byte number (within safe integer range)
+      // db0000000000000064 (tag 100, 8-byte encoding) + 00 (value)
+      const result = parseTag('db000000000000006400')
+      expect(result.value.tag).toBe(100)
+    })
+
+    it('should throw error for tag number exceeding MAX_SAFE_INTEGER', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag number larger than MAX_SAFE_INTEGER (2^53 - 1)
+      // db0020000000000000 (tag 2^53) + 00 (value)
+      expect(() => parseTag('db002000000000000000')).toThrow('Tag number')
+      expect(() => parseTag('db002000000000000000')).toThrow('exceeds maximum safe integer')
+    })
+
+    it('should throw error for reserved AI 28', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 6, AI 28 - reserved
+      expect(() => parseTag('dc')).toThrow('Reserved additional info 28 for major type 6')
+    })
+
+    it('should throw error for reserved AI 29', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 6, AI 29 - reserved
+      expect(() => parseTag('dd')).toThrow('Reserved additional info 29 for major type 6')
+    })
+
+    it('should throw error for reserved AI 30', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 6, AI 30 - reserved
+      expect(() => parseTag('de')).toThrow('Reserved additional info 30 for major type 6')
+    })
+
+    it('should throw error for AI 31 (break marker invalid for tags)', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 6, AI 31 - invalid for tags (break marker)
+      expect(() => parseTag('df')).toThrow('Invalid additional info 31 for tags')
+    })
+  })
+
+  describe('Nested Tags', () => {
+    it('should parse doubly-nested tags', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 containing Tag 1 containing 100
+      // c0 (tag 0) + c1 (tag 1) + 1864 (100)
+      const result = parseTag('c0c11864')
+      expect(result.value).toEqual({
+        tag: 0,
+        value: { tag: 1, value: 100 }
+      })
+    })
+
+    it('should parse triply-nested tags', () => {
+      const { parseTag } = useCborTag()
+
+      // Tag 0 containing Tag 1 containing Tag 2 containing 0
+      // c0 (tag 0) + c1 (tag 1) + c2 (tag 2) + 00 (0)
+      const result = parseTag('c0c1c200')
+      expect(result.value).toEqual({
+        tag: 0,
+        value: { tag: 1, value: { tag: 2, value: 0 } }
+      })
+    })
+  })
+
+  describe('parse() alias', () => {
+    it('should work identically to parseTag', () => {
+      const { parse, parseTag } = useCborTag()
+
+      const hexString = 'c11a514b67b0' // Tag 1 with epoch timestamp
+
+      const parseResult = parse(hexString)
+      const parseTagResult = parseTag(hexString)
+
+      expect(parseResult.value).toEqual(parseTagResult.value)
+      expect(parseResult.bytesRead).toBe(parseTagResult.bytesRead)
+    })
+  })
+
+  describe('Wrong Major Type for Tag', () => {
+    it('should throw error when major type is not 6', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 0 (integer) is not a tag
+      expect(() => parseTag('00')).toThrow('Expected major type 6 (tag), got 0')
+    })
+
+    it('should throw error for MT 7 (simple value)', () => {
+      const { parseTag } = useCborTag()
+
+      // MT 7 (simple value) is not a tag
+      expect(() => parseTag('f4')).toThrow('Expected major type 6 (tag), got 7')
+    })
+  })
+})