89 lines
2.7 KiB
TypeScript
89 lines
2.7 KiB
TypeScript
import { test, expect } from 'vitest';
|
|
import {
|
|
bool,
|
|
clearRegistry,
|
|
enumOf,
|
|
f64,
|
|
list,
|
|
oneOf,
|
|
str,
|
|
type,
|
|
u32,
|
|
u53,
|
|
u8,
|
|
} 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 = type('ShapeOrder', {
|
|
id: u53,
|
|
price: f64,
|
|
qty: f64,
|
|
side: enumOf(['buy', 'sell'] as const),
|
|
tags: list(str),
|
|
});
|
|
|
|
const expectedOrder = ['id', 'price', 'qty', 'side', 'tags'];
|
|
|
|
const d1 = Order.decode(Order.encode({ id: 1, price: 100, qty: 0.5, side: 'buy', tags: ['a'] }));
|
|
const d2 = Order.decode(Order.encode({ id: 999, price: 1e10, qty: 0, side: 'sell', tags: [] }));
|
|
const d3 = Order.decode(
|
|
Order.encode({ id: 2 ** 40, price: -1, qty: 1234, side: 'buy', tags: ['x', 'y', 'z'] }),
|
|
);
|
|
|
|
expect(Object.keys(d1)).toEqual(expectedOrder);
|
|
expect(Object.keys(d2)).toEqual(expectedOrder);
|
|
expect(Object.keys(d3)).toEqual(expectedOrder);
|
|
});
|
|
|
|
test('decoded value types are consistent across instances', () => {
|
|
clearRegistry();
|
|
const T = type('Types', { a: u32, b: f64, c: str, d: bool });
|
|
|
|
const types = (o: Record<string, unknown>) =>
|
|
Object.entries(o).map(([k, v]) => [k, typeof v]);
|
|
|
|
const a = T.decode(T.encode({ a: 1, b: 1.5, c: 'a', d: true }));
|
|
const b = T.decode(T.encode({ a: 0, b: 0, c: '', d: false }));
|
|
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 = type('SPrice', { value: f64, scale: u8 });
|
|
const Order = type('SOrder', { id: u53, price: Price, qty: f64 });
|
|
|
|
const v = { id: 1, price: { value: 100, scale: 2 }, qty: 1 };
|
|
const d1 = Order.decode(Order.encode(v));
|
|
const d2 = Order.decode(Order.encode({ ...v, id: 99 }));
|
|
|
|
expect(Object.keys(d1)).toEqual(['id', 'price', 'qty']);
|
|
expect(Object.keys(d2)).toEqual(['id', 'price', 'qty']);
|
|
expect(Object.keys(d1.price)).toEqual(['value', 'scale']);
|
|
expect(Object.keys(d2.price)).toEqual(['value', 'scale']);
|
|
});
|
|
|
|
test('union decoded objects place discriminator first', () => {
|
|
clearRegistry();
|
|
const Event = oneOf('SEvent', 'kind', {
|
|
a: { x: u32 },
|
|
b: { y: f64 },
|
|
});
|
|
|
|
const ea = Event.decode(Event.encode({ kind: 'a', x: 1 } as never)) as Record<string, unknown>;
|
|
const eb = Event.decode(Event.encode({ kind: 'b', y: 2.5 } as never)) as Record<string, unknown>;
|
|
expect(Object.keys(ea)[0]).toBe('kind');
|
|
expect(Object.keys(eb)[0]).toBe('kind');
|
|
});
|