Skip to content

Commit f95e2a0

Browse files
marcjmarcj
committed
refactor(bson): extract test utilities to shared test-utils.ts
Move expectBytes and toBuffer helpers to a shared test utility file. Update all test files to use the shared helpers instead of local copies.
1 parent 175606f commit f95e2a0

File tree

10 files changed

+105
-169
lines changed

10 files changed

+105
-169
lines changed

‎packages/bson/tests/serialize/all-primitives.spec.ts‎

Lines changed: 39 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ import bson from 'bson';
44
import { MongoId, UUID, float32, float64, int8, int16, int32, uint8, uint16, uint32 } from '@deepkit/type';
55

66
import { getBSONSerializer } from '../../index.js';
7+
import { expectBytes } from '../test-utils.js';
78

89
describe('BSON Serializer - All Primitive Types', () => {
910
describe('string', () => {
@@ -12,35 +13,31 @@ describe('BSON Serializer - All Primitive Types', () => {
1213
name: string;
1314
}
1415
const serialize = getBSONSerializer<Doc>();
15-
const [buffer, size] = serialize({ name: 'hello' });
16-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ name: 'hello' })));
16+
expectBytes(serialize({ name: 'hello' }), bson.serialize({ name: 'hello' }));
1717
});
1818

1919
test('empty string', () => {
2020
interface Doc {
2121
name: string;
2222
}
2323
const serialize = getBSONSerializer<Doc>();
24-
const [buffer, size] = serialize({ name: '' });
25-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ name: '' })));
24+
expectBytes(serialize({ name: '' }), bson.serialize({ name: '' }));
2625
});
2726

2827
test('unicode string', () => {
2928
interface Doc {
3029
name: string;
3130
}
3231
const serialize = getBSONSerializer<Doc>();
33-
const [buffer, size] = serialize({ name: '你好世界' });
34-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ name: '你好世界' })));
32+
expectBytes(serialize({ name: '你好世界' }), bson.serialize({ name: '你好世界' }));
3533
});
3634

3735
test('emoji string', () => {
3836
interface Doc {
3937
name: string;
4038
}
4139
const serialize = getBSONSerializer<Doc>();
42-
const [buffer, size] = serialize({ name: '🎉🚀' });
43-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ name: '🎉🚀' })));
40+
expectBytes(serialize({ name: '🎉🚀' }), bson.serialize({ name: '🎉🚀' }));
4441
});
4542
});
4643

@@ -50,26 +47,23 @@ describe('BSON Serializer - All Primitive Types', () => {
5047
val: number;
5148
}
5249
const serialize = getBSONSerializer<Doc>();
53-
const [buffer, size] = serialize({ val: 42 });
54-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: 42 })));
50+
expectBytes(serialize({ val: 42 }), bson.serialize({ val: 42 }));
5551
});
5652

5753
test('float', () => {
5854
interface Doc {
5955
val: number;
6056
}
6157
const serialize = getBSONSerializer<Doc>();
62-
const [buffer, size] = serialize({ val: 3.14 });
63-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: 3.14 })));
58+
expectBytes(serialize({ val: 3.14 }), bson.serialize({ val: 3.14 }));
6459
});
6560

6661
test('large integer (exceeds int32)', () => {
6762
interface Doc {
6863
val: number;
6964
}
7065
const serialize = getBSONSerializer<Doc>();
71-
const [buffer, size] = serialize({ val: 9007199254740991 });
72-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: 9007199254740991 })));
66+
expectBytes(serialize({ val: 9007199254740991 }), bson.serialize({ val: 9007199254740991 }));
7367
});
7468
});
7569

@@ -153,17 +147,15 @@ describe('BSON Serializer - All Primitive Types', () => {
153147
active: boolean;
154148
}
155149
const serialize = getBSONSerializer<Doc>();
156-
const [buffer, size] = serialize({ active: true });
157-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ active: true })));
150+
expectBytes(serialize({ active: true }), bson.serialize({ active: true }));
158151
});
159152

160153
test('false', () => {
161154
interface Doc {
162155
active: boolean;
163156
}
164157
const serialize = getBSONSerializer<Doc>();
165-
const [buffer, size] = serialize({ active: false });
166-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ active: false })));
158+
expectBytes(serialize({ active: false }), bson.serialize({ active: false }));
167159
});
168160
});
169161

@@ -173,18 +165,17 @@ describe('BSON Serializer - All Primitive Types', () => {
173165
val: bigint;
174166
}
175167
const serialize = getBSONSerializer<Doc>();
176-
const [buffer, size] = serialize({ val: 9007199254740993n });
177-
expect(buffer[4]).toBe(0x12); // LONG type
178-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: bson.Long.fromBigInt(9007199254740993n) })));
168+
const result = serialize({ val: 9007199254740993n });
169+
expect(result[0][4]).toBe(0x12); // LONG type
170+
expectBytes(result, bson.serialize({ val: bson.Long.fromBigInt(9007199254740993n) }));
179171
});
180172

181173
test('negative bigint', () => {
182174
interface Doc {
183175
val: bigint;
184176
}
185177
const serialize = getBSONSerializer<Doc>();
186-
const [buffer, size] = serialize({ val: -9007199254740993n });
187-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: bson.Long.fromBigInt(-9007199254740993n) })));
178+
expectBytes(serialize({ val: -9007199254740993n }), bson.serialize({ val: bson.Long.fromBigInt(-9007199254740993n) }));
188179
});
189180
});
190181

@@ -194,9 +185,9 @@ describe('BSON Serializer - All Primitive Types', () => {
194185
val: null;
195186
}
196187
const serialize = getBSONSerializer<Doc>();
197-
const [buffer, size] = serialize({ val: null });
198-
expect(buffer[4]).toBe(0x0a); // NULL type
199-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ val: null })));
188+
const result = serialize({ val: null });
189+
expect(result[0][4]).toBe(0x0a); // NULL type
190+
expectBytes(result, bson.serialize({ val: null }));
200191
});
201192
});
202193

@@ -207,18 +198,17 @@ describe('BSON Serializer - All Primitive Types', () => {
207198
}
208199
const serialize = getBSONSerializer<Doc>();
209200
const date = new Date('2024-01-15T10:30:00.000Z');
210-
const [buffer, size] = serialize({ created: date });
211-
expect(buffer[4]).toBe(0x09); // DATE type
212-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ created: date })));
201+
const result = serialize({ created: date });
202+
expect(result[0][4]).toBe(0x09); // DATE type
203+
expectBytes(result, bson.serialize({ created: date }));
213204
});
214205

215206
test('epoch date', () => {
216207
interface Doc {
217208
date: Date;
218209
}
219210
const serialize = getBSONSerializer<Doc>();
220-
const [buffer, size] = serialize({ date: new Date(0) });
221-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ date: new Date(0) })));
211+
expectBytes(serialize({ date: new Date(0) }), bson.serialize({ date: new Date(0) }));
222212
});
223213
});
224214

@@ -229,9 +219,9 @@ describe('BSON Serializer - All Primitive Types', () => {
229219
}
230220
const serialize = getBSONSerializer<Doc>();
231221
const uuid = '550e8400-e29b-41d4-a716-446655440000';
232-
const [buffer, size] = serialize({ id: uuid });
233-
expect(buffer[4]).toBe(0x05); // BINARY type
234-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ id: new bson.UUID(uuid) })));
222+
const result = serialize({ id: uuid });
223+
expect(result[0][4]).toBe(0x05); // BINARY type
224+
expectBytes(result, bson.serialize({ id: new bson.UUID(uuid) }));
235225
});
236226
});
237227

@@ -242,9 +232,9 @@ describe('BSON Serializer - All Primitive Types', () => {
242232
}
243233
const serialize = getBSONSerializer<Doc>();
244234
const oid = '507f1f77bcf86cd799439011';
245-
const [buffer, size] = serialize({ _id: oid });
246-
expect(buffer[4]).toBe(0x07); // OID type
247-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ _id: new bson.ObjectId(oid) })));
235+
const result = serialize({ _id: oid });
236+
expect(result[0][4]).toBe(0x07); // OID type
237+
expectBytes(result, bson.serialize({ _id: new bson.ObjectId(oid) }));
248238
});
249239
});
250240

@@ -255,9 +245,9 @@ describe('BSON Serializer - All Primitive Types', () => {
255245
}
256246
const serialize = getBSONSerializer<Doc>();
257247
const data = new Uint8Array([1, 2, 3, 4, 5]);
258-
const [buffer, size] = serialize({ data });
259-
expect(buffer[4]).toBe(0x05); // BINARY type
260-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ data: new bson.Binary(data) })));
248+
const result = serialize({ data });
249+
expect(result[0][4]).toBe(0x05); // BINARY type
250+
expectBytes(result, bson.serialize({ data: new bson.Binary(data) }));
261251
});
262252

263253
test('empty binary', () => {
@@ -266,8 +256,7 @@ describe('BSON Serializer - All Primitive Types', () => {
266256
}
267257
const serialize = getBSONSerializer<Doc>();
268258
const data = new Uint8Array([]);
269-
const [buffer, size] = serialize({ data });
270-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ data: new bson.Binary(data) })));
259+
expectBytes(serialize({ data }), bson.serialize({ data: new bson.Binary(data) }));
271260
});
272261
});
273262

@@ -278,9 +267,9 @@ describe('BSON Serializer - All Primitive Types', () => {
278267
}
279268
const serialize = getBSONSerializer<Doc>();
280269
const data = new Uint8Array([1, 2, 3, 4, 5]).buffer;
281-
const [buffer, size] = serialize({ data });
282-
expect(buffer[4]).toBe(0x05); // BINARY type
283-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ data: new bson.Binary(new Uint8Array(data)) })));
270+
const result = serialize({ data });
271+
expect(result[0][4]).toBe(0x05); // BINARY type
272+
expectBytes(result, bson.serialize({ data: new bson.Binary(new Uint8Array(data)) }));
284273
});
285274
});
286275

@@ -291,9 +280,9 @@ describe('BSON Serializer - All Primitive Types', () => {
291280
}
292281
const serialize = getBSONSerializer<Doc>();
293282
const regex = /hello/i;
294-
const [buffer, size] = serialize({ pattern: regex });
295-
expect(buffer[4]).toBe(0x0b); // REGEX type
296-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ pattern: new bson.BSONRegExp('hello', 'i') })));
283+
const result = serialize({ pattern: regex });
284+
expect(result[0][4]).toBe(0x0b); // REGEX type
285+
expectBytes(result, bson.serialize({ pattern: new bson.BSONRegExp('hello', 'i') }));
297286
});
298287

299288
test('regex with multiple flags', () => {
@@ -302,8 +291,7 @@ describe('BSON Serializer - All Primitive Types', () => {
302291
}
303292
const serialize = getBSONSerializer<Doc>();
304293
const regex = /test/im;
305-
const [buffer, size] = serialize({ pattern: regex });
306-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(bson.serialize({ pattern: new bson.BSONRegExp('test', 'im') })));
294+
expectBytes(serialize({ pattern: regex }), bson.serialize({ pattern: new bson.BSONRegExp('test', 'im') }));
307295
});
308296
});
309297

@@ -330,7 +318,6 @@ describe('BSON Serializer - All Primitive Types', () => {
330318
data: new Uint8Array([1, 2, 3]),
331319
};
332320

333-
const [buffer, size] = serialize(doc);
334321
const expected = bson.serialize({
335322
_id: new bson.ObjectId(doc._id),
336323
name: doc.name,
@@ -341,7 +328,7 @@ describe('BSON Serializer - All Primitive Types', () => {
341328
data: new bson.Binary(doc.data),
342329
});
343330

344-
expect(Array.from(buffer.slice(0, size))).toEqual(Array.from(expected));
331+
expectBytes(serialize(doc), expected);
345332
});
346333
});
347334
});

‎packages/bson/tests/serialize/arrays.spec.ts‎

Lines changed: 9 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -4,43 +4,32 @@
44
import { expect, test } from '@jest/globals';
55
import bson from 'bson';
66

7-
import { SerializeResult, deserializeBSONWithoutOptimiser, getBSONDeserializer, getBSONSerializer } from '../../index.js';
7+
import { deserializeBSONWithoutOptimiser, getBSONDeserializer, getBSONSerializer } from '../../index.js';
8+
import { expectBytes, toBuffer } from '../test-utils.js';
89

910
const { serialize } = bson;
1011

11-
// Helper to extract buffer from tuple result and compare bytes
12-
function expectBsonEqual(result: SerializeResult, expected: Uint8Array) {
13-
const [buffer, size] = result;
14-
expect(Array.from(buffer.subarray(0, size))).toEqual(Array.from(expected));
15-
}
16-
17-
// Helper to get buffer slice from tuple
18-
function toBuffer(result: SerializeResult): Uint8Array {
19-
const [buffer, size] = result;
20-
return buffer.slice(0, size);
21-
}
22-
2312
test('string array', () => {
2413
const serializer = getBSONSerializer<{ name: string[] }>();
2514
const object = { name: ['Peter3'] };
26-
expectBsonEqual(serializer(object), serialize(object));
15+
expectBytes(serializer(object), serialize(object));
2716
});
2817

2918
test('number array', () => {
3019
const serializer = getBSONSerializer<{ values: number[] }>();
31-
expectBsonEqual(serializer({ values: [1, 2, 3] }), serialize({ values: [1, 2, 3] }));
32-
expectBsonEqual(serializer({ values: [] }), serialize({ values: [] }));
20+
expectBytes(serializer({ values: [1, 2, 3] }), serialize({ values: [1, 2, 3] }));
21+
expectBytes(serializer({ values: [] }), serialize({ values: [] }));
3322
});
3423

3524
test('mixed type array', () => {
3625
const serializer = getBSONSerializer<{ items: (string | number)[] }>();
37-
expectBsonEqual(serializer({ items: ['a', 1, 'b', 2] }), serialize({ items: ['a', 1, 'b', 2] }));
26+
expectBytes(serializer({ items: ['a', 1, 'b', 2] }), serialize({ items: ['a', 1, 'b', 2] }));
3827
});
3928

4029
test('Set serializes as array', () => {
4130
const serializer = getBSONSerializer<{ name: Set<string> }>();
4231
const object = { name: new Set(['abc', 'Peter']) };
43-
expectBsonEqual(serializer(object), serialize({ name: ['abc', 'Peter'] }));
32+
expectBytes(serializer(object), serialize({ name: ['abc', 'Peter'] }));
4433
});
4534

4635
test('Set round-trip', () => {
@@ -62,7 +51,7 @@ test('nested array', () => {
6251
[5, 6],
6352
],
6453
};
65-
expectBsonEqual(serializer(object), serialize(object));
54+
expectBytes(serializer(object), serialize(object));
6655
});
6756

6857
test('array of objects', () => {
@@ -73,7 +62,7 @@ test('array of objects', () => {
7362
{ id: 2, name: 'b' },
7463
],
7564
};
76-
expectBsonEqual(serializer(object), serialize(object));
65+
expectBytes(serializer(object), serialize(object));
7766
});
7867

7968
test('array round-trip', () => {

‎packages/bson/tests/serialize/binary.spec.ts‎

Lines changed: 2 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -6,16 +6,11 @@ import bson from 'bson';
66

77
import { MongoId, nodeBufferToArrayBuffer } from '@deepkit/type';
88

9-
import { SerializeResult, getBSONSerializer } from '../../index.js';
9+
import { getBSONSerializer } from '../../index.js';
10+
import { expectBytes } from '../test-utils.js';
1011

1112
const { Binary, ObjectId: OfficialObjectId, serialize } = bson;
1213

13-
// Helper to compare bytes (Buffer vs Uint8Array)
14-
function expectBytes(result: SerializeResult, expected: Uint8Array | Buffer): void {
15-
const [buffer, size] = result;
16-
expect(Array.from(buffer.subarray(0, size))).toEqual(Array.from(expected));
17-
}
18-
1914
test('Uint8Array', () => {
2015
const serializer = getBSONSerializer<{ binary: Uint8Array }>();
2116
const data = { binary: new Uint8Array(32) };

0 commit comments

Comments
 (0)