wehub-resource-sync
406 lines
13 KiB
TypeScript
406 lines
13 KiB
TypeScript
import type { JsonStreamEvent } from '../src/index'
|
|
import { describe, expect, it } from 'vitest'
|
|
import { buildValueFromEvents, buildValueFromEventsAsync } from '../src/decode/event-builder'
|
|
import { decode, decodeFromLines, decodeStream, decodeStreamSync } from '../src/index'
|
|
|
|
describe('streaming decode', () => {
|
|
describe('decodeStreamSync', () => {
|
|
it('decodes simple object', () => {
|
|
const input = 'name: Alice\nage: 30'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'name' },
|
|
{ type: 'primitive', value: 'Alice' },
|
|
{ type: 'key', key: 'age' },
|
|
{ type: 'primitive', value: 30 },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes nested object', () => {
|
|
const input = 'user:\n name: Alice\n age: 30'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'user' },
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'name' },
|
|
{ type: 'primitive', value: 'Alice' },
|
|
{ type: 'key', key: 'age' },
|
|
{ type: 'primitive', value: 30 },
|
|
{ type: 'endObject' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes inline primitive array', () => {
|
|
const input = 'scores[3]: 95, 87, 92'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'scores' },
|
|
{ type: 'startArray', length: 3 },
|
|
{ type: 'primitive', value: 95 },
|
|
{ type: 'primitive', value: 87 },
|
|
{ type: 'primitive', value: 92 },
|
|
{ type: 'endArray' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes inline array with empty string key', () => {
|
|
const input = '""[2]: 1,2'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: '' },
|
|
{ type: 'startArray', length: 2 },
|
|
{ type: 'primitive', value: 1 },
|
|
{ type: 'primitive', value: 2 },
|
|
{ type: 'endArray' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes list array', () => {
|
|
const input = 'items[2]:\n - Apple\n - Banana'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'items' },
|
|
{ type: 'startArray', length: 2 },
|
|
{ type: 'primitive', value: 'Apple' },
|
|
{ type: 'primitive', value: 'Banana' },
|
|
{ type: 'endArray' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes tabular array', () => {
|
|
const input = 'users[2]{name,age}:\n Alice, 30\n Bob, 25'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'users' },
|
|
{ type: 'startArray', length: 2 },
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'name' },
|
|
{ type: 'primitive', value: 'Alice' },
|
|
{ type: 'key', key: 'age' },
|
|
{ type: 'primitive', value: 30 },
|
|
{ type: 'endObject' },
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'name' },
|
|
{ type: 'primitive', value: 'Bob' },
|
|
{ type: 'key', key: 'age' },
|
|
{ type: 'primitive', value: 25 },
|
|
{ type: 'endObject' },
|
|
{ type: 'endArray' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('decodes root primitive', () => {
|
|
const input = 'Hello World'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'primitive', value: 'Hello World' },
|
|
])
|
|
})
|
|
|
|
it('decodes root array', () => {
|
|
const input = '[2]:\n - Apple\n - Banana'
|
|
const lines = input.split('\n')
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startArray', length: 2 },
|
|
{ type: 'primitive', value: 'Apple' },
|
|
{ type: 'primitive', value: 'Banana' },
|
|
{ type: 'endArray' },
|
|
])
|
|
})
|
|
|
|
it('decodes empty input as empty object', () => {
|
|
const lines: string[] = []
|
|
const events = Array.from(decodeStreamSync(lines))
|
|
|
|
expect(events).toEqual([
|
|
{ type: 'startObject' },
|
|
{ type: 'endObject' },
|
|
])
|
|
})
|
|
|
|
it('throws on expandPaths option', () => {
|
|
const input = 'name: Alice'
|
|
const lines = input.split('\n')
|
|
|
|
expect(() => Array.from(decodeStreamSync(lines, { expandPaths: 'safe' } as any)))
|
|
.toThrow('expandPaths is not supported in streaming decode')
|
|
})
|
|
|
|
it('enforces strict mode validation', () => {
|
|
const input = 'items[2]:\n - Apple'
|
|
const lines = input.split('\n')
|
|
|
|
expect(() => Array.from(decodeStreamSync(lines, { strict: true })))
|
|
.toThrow()
|
|
})
|
|
|
|
it('allows count mismatch in non-strict mode', () => {
|
|
const input = 'items[2]:\n - Apple'
|
|
const lines = input.split('\n')
|
|
|
|
const events = Array.from(decodeStreamSync(lines, { strict: false }))
|
|
|
|
expect(events).toBeDefined()
|
|
expect(events[0]).toEqual({ type: 'startObject' })
|
|
})
|
|
})
|
|
|
|
describe('decodeStream (async)', () => {
|
|
const equivalenceCases = [
|
|
{ name: 'simple object', input: 'name: Alice\nage: 30' },
|
|
{ name: 'nested object', input: 'user:\n name: Alice\n age: 30' },
|
|
{ name: 'tabular array', input: 'users[2]{name,age}:\n Alice, 30\n Bob, 25' },
|
|
{ name: 'list array', input: 'items[2]:\n - Apple\n - Banana' },
|
|
{ name: 'root primitive', input: 'Hello World' },
|
|
{ name: 'root array', input: '[2]:\n - Apple\n - Banana' },
|
|
{ name: 'empty input', input: '' },
|
|
]
|
|
|
|
for (const { name, input } of equivalenceCases) {
|
|
it(`emits the same events as decodeStreamSync for ${name}`, async () => {
|
|
const lines = input === '' ? [] : input.split('\n')
|
|
const syncResult = Array.from(decodeStreamSync(lines))
|
|
const asyncResult = await collect(decodeStream(asyncLines(lines)))
|
|
expect(asyncResult).toEqual(syncResult)
|
|
})
|
|
}
|
|
|
|
it('accepts a sync iterable as source', async () => {
|
|
const lines = ['name: Alice', 'age: 30']
|
|
const events = await collect(decodeStream(lines))
|
|
|
|
expect(events).toEqual(Array.from(decodeStreamSync(lines)))
|
|
})
|
|
|
|
it('rejects expandPaths option', async () => {
|
|
const lines = ['name: Alice']
|
|
|
|
await expect(async () => {
|
|
await collect(decodeStream(asyncLines(lines), { expandPaths: 'safe' } as any))
|
|
}).rejects.toThrow('expandPaths is not supported in streaming decode')
|
|
})
|
|
|
|
it('enforces strict mode validation', async () => {
|
|
const lines = ['items[2]:', ' - Apple']
|
|
|
|
await expect(async () => {
|
|
await collect(decodeStream(asyncLines(lines), { strict: true }))
|
|
}).rejects.toThrow()
|
|
})
|
|
|
|
it('allows count mismatch in non-strict mode', async () => {
|
|
const lines = ['items[2]:', ' - Apple']
|
|
const events = await collect(decodeStream(asyncLines(lines), { strict: false }))
|
|
|
|
expect(events[0]).toEqual({ type: 'startObject' })
|
|
})
|
|
})
|
|
|
|
describe('buildValueFromEvents', () => {
|
|
it('builds object from events', () => {
|
|
const events = [
|
|
{ type: 'startObject' as const },
|
|
{ type: 'key' as const, key: 'name' },
|
|
{ type: 'primitive' as const, value: 'Alice' },
|
|
{ type: 'key' as const, key: 'age' },
|
|
{ type: 'primitive' as const, value: 30 },
|
|
{ type: 'endObject' as const },
|
|
]
|
|
|
|
const result = buildValueFromEvents(events)
|
|
|
|
expect(result).toEqual({ name: 'Alice', age: 30 })
|
|
})
|
|
|
|
it('builds nested object from events', () => {
|
|
const events = [
|
|
{ type: 'startObject' as const },
|
|
{ type: 'key' as const, key: 'user' },
|
|
{ type: 'startObject' as const },
|
|
{ type: 'key' as const, key: 'name' },
|
|
{ type: 'primitive' as const, value: 'Alice' },
|
|
{ type: 'endObject' as const },
|
|
{ type: 'endObject' as const },
|
|
]
|
|
|
|
const result = buildValueFromEvents(events)
|
|
|
|
expect(result).toEqual({ user: { name: 'Alice' } })
|
|
})
|
|
|
|
it('builds array from events', () => {
|
|
const events = [
|
|
{ type: 'startArray' as const, length: 3 },
|
|
{ type: 'primitive' as const, value: 1 },
|
|
{ type: 'primitive' as const, value: 2 },
|
|
{ type: 'primitive' as const, value: 3 },
|
|
{ type: 'endArray' as const },
|
|
]
|
|
|
|
const result = buildValueFromEvents(events)
|
|
|
|
expect(result).toEqual([1, 2, 3])
|
|
})
|
|
|
|
it('builds primitive from events', () => {
|
|
const events = [
|
|
{ type: 'primitive' as const, value: 'Hello' },
|
|
]
|
|
|
|
const result = buildValueFromEvents(events)
|
|
|
|
expect(result).toEqual('Hello')
|
|
})
|
|
|
|
it('throws on incomplete event stream', () => {
|
|
const events = [
|
|
{ type: 'startObject' as const },
|
|
{ type: 'key' as const, key: 'name' },
|
|
]
|
|
|
|
expect(() => buildValueFromEvents(events))
|
|
.toThrow('Incomplete event stream')
|
|
})
|
|
})
|
|
|
|
describe('buildValueFromEventsAsync', () => {
|
|
it('matches buildValueFromEvents for representative shapes', async () => {
|
|
const cases: JsonStreamEvent[][] = [
|
|
[
|
|
{ type: 'startObject' },
|
|
{ type: 'key', key: 'name' },
|
|
{ type: 'primitive', value: 'Alice' },
|
|
{ type: 'endObject' },
|
|
],
|
|
[
|
|
{ type: 'startArray', length: 2 },
|
|
{ type: 'primitive', value: 1 },
|
|
{ type: 'primitive', value: 2 },
|
|
{ type: 'endArray' },
|
|
],
|
|
[
|
|
{ type: 'primitive', value: 'Hello' },
|
|
],
|
|
]
|
|
|
|
for (const events of cases) {
|
|
const syncResult = buildValueFromEvents(events)
|
|
const asyncResult = await buildValueFromEventsAsync(asyncEvents(events))
|
|
expect(asyncResult).toEqual(syncResult)
|
|
}
|
|
})
|
|
|
|
it('throws on incomplete event stream', async () => {
|
|
const events = [
|
|
{ type: 'startObject' as const },
|
|
{ type: 'key' as const, key: 'name' },
|
|
]
|
|
|
|
await expect(buildValueFromEventsAsync(asyncEvents(events)))
|
|
.rejects
|
|
.toThrow('Incomplete event stream')
|
|
})
|
|
})
|
|
|
|
describe('decodeFromLines', () => {
|
|
it('produces same result as decode', () => {
|
|
const input = 'name: Alice\nage: 30\nscores[3]: 95, 87, 92'
|
|
const lines = input.split('\n')
|
|
|
|
expect(decodeFromLines(lines)).toEqual(decode(input))
|
|
})
|
|
|
|
it('supports expandPaths option', () => {
|
|
const lines = ['user.name: Alice', 'user.age: 30']
|
|
|
|
expect(decodeFromLines(lines, { expandPaths: 'safe' })).toEqual({
|
|
user: { name: 'Alice', age: 30 },
|
|
})
|
|
})
|
|
|
|
it('handles list item objects with empty string keyed tabular fields', () => {
|
|
const input = [
|
|
'items[1]:',
|
|
' - ""[2]{a}:',
|
|
' 1',
|
|
' 2',
|
|
].join('\n')
|
|
|
|
expect(decodeFromLines(input.split('\n'))).toEqual({
|
|
items: [{ '': [{ a: 1 }, { a: 2 }] }],
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('streaming equivalence', () => {
|
|
const testCases = [
|
|
{ name: 'simple object', input: 'name: Alice\nage: 30' },
|
|
{ name: 'nested objects', input: 'user:\n profile:\n name: Alice\n age: 30' },
|
|
{ name: 'mixed structures', input: 'name: Alice\nscores[3]: 95, 87, 92\naddress:\n city: NYC\n zip: 10001' },
|
|
{ name: 'list array with objects', input: 'users[2]:\n - name: Alice\n age: 30\n - name: Bob\n age: 25' },
|
|
{ name: 'tabular array', input: 'users[3]{name,age,city}:\n Alice, 30, NYC\n Bob, 25, LA\n Charlie, 35, SF' },
|
|
{ name: 'root primitive number', input: '42' },
|
|
{ name: 'root primitive string', input: 'Hello World' },
|
|
{ name: 'root primitive boolean', input: 'true' },
|
|
{ name: 'root primitive null', input: 'null' },
|
|
]
|
|
|
|
for (const testCase of testCases) {
|
|
it(`decodeFromLines matches decode() for: ${testCase.name}`, () => {
|
|
const lines = testCase.input.split('\n')
|
|
expect(decodeFromLines(lines)).toEqual(decode(testCase.input))
|
|
})
|
|
}
|
|
})
|
|
})
|
|
|
|
async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
|
|
const results: T[] = []
|
|
for await (const item of iterable) {
|
|
results.push(item)
|
|
}
|
|
return results
|
|
}
|
|
|
|
async function* asyncLines(lines: string[]): AsyncGenerator<string> {
|
|
for (const line of lines) {
|
|
await Promise.resolve()
|
|
yield line
|
|
}
|
|
}
|
|
|
|
async function* asyncEvents<T>(events: T[]): AsyncGenerator<T> {
|
|
for (const event of events) {
|
|
await Promise.resolve()
|
|
yield event
|
|
}
|
|
}
|