106 lines
3.3 KiB
TypeScript
106 lines
3.3 KiB
TypeScript
import { test, expect } from 'vitest';
|
|
import {
|
|
clearRegistry,
|
|
defineSchema,
|
|
deserialize,
|
|
register,
|
|
s,
|
|
serialize,
|
|
} from '../plugin/index.ts';
|
|
|
|
/**
|
|
* Decoded objects must share key order with the schema field order. Same
|
|
* key order across instances is V8's strongest signal of a shared hidden
|
|
* class, which is what the codec's single-object-literal pattern ensures.
|
|
*/
|
|
test('decoded objects share key order matching schema field order', () => {
|
|
clearRegistry();
|
|
const Order = defineSchema('ShapeOrder', (s) => ({
|
|
id: s.u53,
|
|
price: s.f64,
|
|
qty: s.f64,
|
|
side: s.enum(['buy', 'sell'] as const),
|
|
tags: s.array(s.str),
|
|
}));
|
|
const codec = register(Order);
|
|
|
|
const expectedOrder = ['id', 'price', 'qty', 'side', 'tags'];
|
|
|
|
const decoded1 = deserialize<Record<string, unknown>>(
|
|
serialize({ id: 1, price: 100, qty: 0.5, side: 'buy', tags: ['a'] }, codec),
|
|
);
|
|
const decoded2 = deserialize<Record<string, unknown>>(
|
|
serialize({ id: 999, price: 1e10, qty: 0, side: 'sell', tags: [] }, codec),
|
|
);
|
|
const decoded3 = deserialize<Record<string, unknown>>(
|
|
serialize({ id: 2 ** 40, price: -1, qty: 1234, side: 'buy', tags: ['x', 'y', 'z'] }, codec),
|
|
);
|
|
|
|
expect(Object.keys(decoded1)).toEqual(expectedOrder);
|
|
expect(Object.keys(decoded2)).toEqual(expectedOrder);
|
|
expect(Object.keys(decoded3)).toEqual(expectedOrder);
|
|
});
|
|
|
|
test('decoded value types are consistent across instances', () => {
|
|
clearRegistry();
|
|
const T = defineSchema('Types', (s) => ({
|
|
a: s.u32,
|
|
b: s.f64,
|
|
c: s.str,
|
|
d: s.bool,
|
|
}));
|
|
const codec = register(T);
|
|
|
|
const types = (o: Record<string, unknown>) =>
|
|
Object.entries(o).map(([k, v]) => [k, typeof v]);
|
|
|
|
const a = deserialize<Record<string, unknown>>(
|
|
serialize({ a: 1, b: 1.5, c: 'a', d: true }, codec),
|
|
);
|
|
const b = deserialize<Record<string, unknown>>(
|
|
serialize({ a: 0, b: 0, c: '', d: false }, codec),
|
|
);
|
|
expect(types(a)).toEqual(types(b));
|
|
expect(types(a)).toEqual([
|
|
['a', 'number'],
|
|
['b', 'number'],
|
|
['c', 'string'],
|
|
['d', 'boolean'],
|
|
]);
|
|
});
|
|
|
|
test('nested object key order is stable', () => {
|
|
clearRegistry();
|
|
const Price = defineSchema('SPrice', (s) => ({ value: s.f64, scale: s.u8 }));
|
|
register(Price);
|
|
const Order = defineSchema('SOrder', (s) => ({
|
|
id: s.u53,
|
|
price: Price,
|
|
qty: s.f64,
|
|
}));
|
|
const codec = register(Order);
|
|
|
|
const v = { id: 1, price: { value: 100, scale: 2 }, qty: 1 };
|
|
const d1 = deserialize<Record<string, unknown>>(serialize(v, codec));
|
|
const d2 = deserialize<Record<string, unknown>>(serialize({ ...v, id: 99 }, codec));
|
|
|
|
expect(Object.keys(d1)).toEqual(['id', 'price', 'qty']);
|
|
expect(Object.keys(d2)).toEqual(['id', 'price', 'qty']);
|
|
expect(Object.keys(d1.price as Record<string, unknown>)).toEqual(['value', 'scale']);
|
|
expect(Object.keys(d2.price as Record<string, unknown>)).toEqual(['value', 'scale']);
|
|
});
|
|
|
|
test('union decoded objects place discriminator first', () => {
|
|
clearRegistry();
|
|
const Event = s.union('SEvent', 'kind', {
|
|
a: { x: s.u32 },
|
|
b: { y: s.f64 },
|
|
});
|
|
const codec = register(Event);
|
|
|
|
const ea = deserialize<Record<string, unknown>>(serialize({ kind: 'a', x: 1 }, codec));
|
|
const eb = deserialize<Record<string, unknown>>(serialize({ kind: 'b', y: 2.5 }, codec));
|
|
expect(Object.keys(ea)[0]).toBe('kind');
|
|
expect(Object.keys(eb)[0]).toBe('kind');
|
|
});
|