Tianyi Cui
1709b8cfee
A direct runtime import of the session package made the unbuilt worker depend on sibling lib output. Use a parity-tested local JSON snapshotter and pin the isolated source closure with a real-worker test.
88 lines
2.9 KiB
TypeScript
88 lines
2.9 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { snapshotJsonValue } from '@deepseek-ai/dsh-session'
|
|
import { snapshotCodeJsonValue } from '../src/worker-json.ts'
|
|
|
|
describe('snapshotCodeJsonValue', () => {
|
|
it('matches the canonical scalar boundary', () => {
|
|
const unsupported = [undefined, 1n, Symbol('value'), () => 1]
|
|
for (const value of [null, false, 'text', 1.25, -0, Number.NaN, Number.POSITIVE_INFINITY, ...unsupported]) {
|
|
expect(snapshotCodeJsonValue(value)).toEqual(snapshotJsonValue(value))
|
|
}
|
|
})
|
|
|
|
it('detaches dense arrays and plain or null-prototype records', () => {
|
|
const shared = { value: 1 }
|
|
const nullPrototype = Object.assign(Object.create(null) as Record<string, unknown>, { shared })
|
|
const source = { list: [nullPrototype, shared], alias: shared }
|
|
|
|
const snapshot = snapshotCodeJsonValue(source) as Record<string, unknown>
|
|
shared.value = 2
|
|
|
|
expect(snapshot).toEqual({ list: [{ shared: { value: 1 } }, { value: 1 }], alias: { value: 1 } })
|
|
expect(snapshot).not.toBe(source)
|
|
expect((snapshot.list as unknown[])[0]).not.toBe(nullPrototype)
|
|
expect(snapshot.alias).not.toBe(shared)
|
|
})
|
|
|
|
it('reads each accepted slot once and preserves a literal __proto__ key', () => {
|
|
let objectReads = 0
|
|
let arrayReads = 0
|
|
const source = Object.create(null) as Record<string, unknown>
|
|
Object.defineProperty(source, '__proto__', {
|
|
enumerable: true,
|
|
get: () => {
|
|
objectReads += 1
|
|
return { safe: true }
|
|
},
|
|
})
|
|
const array = new Array<unknown>(1)
|
|
Object.defineProperty(array, 0, {
|
|
enumerable: true,
|
|
get: () => {
|
|
arrayReads += 1
|
|
return arrayReads === 1 ? source : undefined
|
|
},
|
|
})
|
|
|
|
const snapshot = snapshotCodeJsonValue(array) as Record<string, unknown>[]
|
|
|
|
expect(objectReads).toBe(1)
|
|
expect(arrayReads).toBe(1)
|
|
expect(Object.getPrototypeOf(snapshot[0])).toBe(Object.prototype)
|
|
expect(Object.hasOwn(snapshot[0]!, '__proto__')).toBe(true)
|
|
expect(snapshot[0]?.['__proto__']).toEqual({ safe: true })
|
|
})
|
|
|
|
it('rejects exotic containers, sparse arrays, cycles, and invalid children', () => {
|
|
class ExoticObject {
|
|
readonly value = 1
|
|
}
|
|
class ExoticArray extends Array<number> {}
|
|
const cyclic: Record<string, unknown> = {}
|
|
cyclic.self = cyclic
|
|
|
|
for (const value of [
|
|
new ExoticObject(),
|
|
new Map([['value', 1]]),
|
|
new ExoticArray(1),
|
|
new Array(1),
|
|
cyclic,
|
|
[undefined],
|
|
{ value: undefined },
|
|
]) {
|
|
expect(snapshotCodeJsonValue(value)).toBeUndefined()
|
|
}
|
|
})
|
|
|
|
it('propagates a throwing getter and releases its recursion guard', () => {
|
|
const failure = new Error('getter failed')
|
|
const source = Object.defineProperty({}, 'value', {
|
|
enumerable: true,
|
|
get: () => { throw failure },
|
|
})
|
|
|
|
expect(() => snapshotCodeJsonValue(source)).toThrow(failure)
|
|
expect(snapshotCodeJsonValue({ after: true })).toEqual({ after: true })
|
|
})
|
|
})
|