Skip to content

Commit 4221278

Browse files
samwillissamwillis
committed
tidy tests
1 parent 912e19b commit 4221278

File tree

3 files changed

+41
-130
lines changed

3 files changed

+41
-130
lines changed

‎packages/d2mini/tests/operators/orderByWithFractionalIndex.test.ts‎

Lines changed: 13 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,11 @@ import {
88
import { orderByWithFractionalIndexBTree } from '../../src/operators/orderByBTree.js'
99
import { KeyValue } from '../../src/types.js'
1010
import { loadBTree } from '../../src/operators/topKWithFractionalIndexBTree.js'
11-
import { MessageTracker } from '../test-utils.js'
11+
import {
12+
MessageTracker,
13+
assertOnlyKeysAffected,
14+
assertKeyedResults,
15+
} from '../test-utils.js'
1216

1317
const stripFractionalIndex = ([[key, [value, _index]], multiplicity]) => [
1418
key,
@@ -365,10 +369,6 @@ describe('Operators', () => {
365369
graph.run()
366370

367371
const initialResult = tracker.getResult()
368-
console.log(
369-
`orderBy initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
370-
)
371-
372372
// Should have the top 3 items by value
373373
expect(initialResult.sortedResults.length).toBe(3)
374374
expect(initialResult.messageCount).toBeLessThanOrEqual(4) // Should be efficient
@@ -384,24 +384,15 @@ describe('Operators', () => {
384384
graph.run()
385385

386386
const updateResult = tracker.getResult()
387-
console.log(
388-
`orderBy remove: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
389-
)
390-
391387
// Should have efficient incremental update
392388
expect(updateResult.messageCount).toBeLessThanOrEqual(4) // Should be incremental
393389
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have changes
394390

395391
// Check that only affected keys produce messages - should be key1 (removed) and key4 (added to top 3)
396-
const affectedKeys = new Set(
397-
updateResult.messages.map(([[key, _value], _mult]) => key),
398-
)
399-
expect(affectedKeys.size).toBeLessThanOrEqual(2) // Should only affect key1 and key4
400-
401-
// Verify specific keys are affected
402-
for (const key of affectedKeys) {
403-
expect(['key1', 'key4'].includes(key)).toBe(true)
404-
}
392+
assertOnlyKeysAffected('orderBy remove', updateResult.messages, [
393+
'key1',
394+
'key4',
395+
])
405396
})
406397

407398
test('incremental update - modifying a row', () => {
@@ -440,10 +431,6 @@ describe('Operators', () => {
440431
graph.run()
441432

442433
const initialResult = tracker.getResult()
443-
console.log(
444-
`orderBy modify initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
445-
)
446-
447434
// Should have the top 3 items by value
448435
expect(initialResult.sortedResults.length).toBe(3)
449436
expect(initialResult.messageCount).toBeLessThanOrEqual(4) // Should be efficient
@@ -460,24 +447,15 @@ describe('Operators', () => {
460447
graph.run()
461448

462449
const updateResult = tracker.getResult()
463-
console.log(
464-
`orderBy modify update: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
465-
)
466-
467450
// Should have efficient incremental update
468451
expect(updateResult.messageCount).toBeLessThanOrEqual(6) // Should be incremental (modify operation)
469452
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have changes
470453

471454
// Check that only affected keys produce messages - should be key2 (modified) and key4 (added to top 3)
472-
const affectedKeys = new Set(
473-
updateResult.messages.map(([[key, _value], _mult]) => key),
474-
)
475-
expect(affectedKeys.size).toBeLessThanOrEqual(2) // Should only affect key2 and key4
476-
477-
// Verify specific keys are affected
478-
for (const key of affectedKeys) {
479-
expect(['key2', 'key4'].includes(key)).toBe(true)
480-
}
455+
assertOnlyKeysAffected('orderBy modify', updateResult.messages, [
456+
'key2',
457+
'key4',
458+
])
481459
})
482460
})
483461
})

‎packages/d2mini/tests/operators/topKWithFractionalIndex.test.ts‎

Lines changed: 22 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ import {
77
topKWithFractionalIndexBTree,
88
} from '../../src/operators/topKWithFractionalIndexBTree.js'
99
import { output } from '../../src/operators/index.js'
10-
import { MessageTracker } from '../test-utils.js'
10+
import { MessageTracker, assertOnlyKeysAffected } from '../test-utils.js'
1111

1212
// Helper function to check if indices are in lexicographic order
1313
function checkLexicographicOrder(results: any[]) {
@@ -102,10 +102,6 @@ describe('Operators', () => {
102102

103103
// Initial result should have all elements with fractional indices
104104
const initialResult = tracker.getResult()
105-
console.log(
106-
`topKFractional initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
107-
)
108-
109105
expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
110106
expect(initialResult.messageCount).toBeLessThanOrEqual(6) // Should be efficient
111107

@@ -130,23 +126,14 @@ describe('Operators', () => {
130126

131127
// Check the incremental changes
132128
const updateResult = tracker.getResult()
133-
console.log(
134-
`topKFractional update: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
135-
)
136-
137129
// Should have reasonable incremental changes (not recomputing everything)
138130
expect(updateResult.messageCount).toBeLessThanOrEqual(4) // Should be incremental
139131
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have some changes
140132

141133
// Check that only the affected key (null) produces messages
142-
const affectedKeys = new Set(
143-
updateResult.messages.map(([[key, _value], _mult]) => key),
144-
)
145-
expect(affectedKeys.size).toBe(1)
146-
expect(affectedKeys.has(null)).toBe(true)
147-
148-
// For TopKWithFractionalIndex, the incremental update might be optimized
149-
// so we mainly verify that the operation is incremental and maintains ordering
134+
assertOnlyKeysAffected('topKFractional update', updateResult.messages, [
135+
null,
136+
])
150137

151138
// Check that the update messages maintain lexicographic order on their own
152139
if (updateResult.messages.length > 0) {
@@ -188,10 +175,6 @@ describe('Operators', () => {
188175

189176
// Initial result should have all elements with fractional indices
190177
const initialResult = tracker.getResult()
191-
console.log(
192-
`topKFractional duplicate keys initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
193-
)
194-
195178
expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
196179
expect(
197180
checkLexicographicOrder(
@@ -207,15 +190,17 @@ describe('Operators', () => {
207190

208191
// Check the incremental changes
209192
const updateResult = tracker.getResult()
210-
console.log(
211-
`topKFractional duplicate keys update: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
212-
)
213-
214193
// Should have efficient incremental update
215194
expect(updateResult.messageCount).toBeLessThanOrEqual(2) // Should be incremental (1 addition)
216195
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have changes
217196

218-
// For TopKWithFractionalIndex, verify that incremental updates maintain ordering
197+
// Check that only the affected key (null) produces messages
198+
assertOnlyKeysAffected(
199+
'topKFractional duplicate keys',
200+
updateResult.messages,
201+
[null],
202+
)
203+
219204
// Check that the update messages maintain lexicographic order on their own
220205
if (updateResult.messages.length > 0) {
221206
const updateMessages = updateResult.messages.map(([item, mult]) => [
@@ -305,10 +290,6 @@ describe('Operators', () => {
305290

306291
// Initial result should be b, c, d (offset 1, limit 3)
307292
const initialResult = tracker.getResult()
308-
console.log(
309-
`topK limit+offset initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
310-
)
311-
312293
expect(initialResult.sortedResults.length).toBe(3) // Should have 3 elements
313294
expect(initialResult.messageCount).toBeLessThanOrEqual(6) // Should be efficient
314295

@@ -337,10 +318,6 @@ describe('Operators', () => {
337318
graph.run()
338319

339320
const updateResult = tracker.getResult()
340-
console.log(
341-
`topK limit+offset update: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
342-
)
343-
344321
// Should have efficient incremental update
345322
expect(updateResult.messageCount).toBeLessThanOrEqual(4) // Should be incremental
346323
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have changes
@@ -349,11 +326,7 @@ describe('Operators', () => {
349326
expect(updateResult.sortedResults.length).toBeLessThanOrEqual(3) // Should respect limit
350327

351328
// Check that only the affected key produces messages
352-
const affectedKeys = new Set(
353-
updateResult.messages.map(([[key, _value], _mult]) => key),
354-
)
355-
expect(affectedKeys.size).toBe(1)
356-
expect(affectedKeys.has(null)).toBe(true)
329+
assertOnlyKeysAffected('topK limit+offset', updateResult.messages, [null])
357330
})
358331

359332
it('should handle elements moving positions correctly', () => {
@@ -385,10 +358,6 @@ describe('Operators', () => {
385358
graph.run()
386359

387360
const initialResult = tracker.getResult()
388-
console.log(
389-
`topK move positions initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
390-
)
391-
392361
expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
393362
expect(initialResult.messageCount).toBeLessThanOrEqual(6) // Should be efficient
394363

@@ -418,20 +387,14 @@ describe('Operators', () => {
418387
graph.run()
419388

420389
const updateResult = tracker.getResult()
421-
console.log(
422-
`topK move positions update: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
423-
)
424-
425390
// Should have efficient incremental update
426391
expect(updateResult.messageCount).toBeLessThanOrEqual(6) // Should be incremental (4 changes max)
427392
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have changes
428393

429394
// Check that only the affected key produces messages
430-
const affectedKeys = new Set(
431-
updateResult.messages.map(([[key, _value], _mult]) => key),
432-
)
433-
expect(affectedKeys.size).toBe(1)
434-
expect(affectedKeys.has(null)).toBe(true)
395+
assertOnlyKeysAffected('topK move positions', updateResult.messages, [
396+
null,
397+
])
435398

436399
// For position swaps, we mainly care that the operation is incremental
437400
// The exact final state depends on the implementation details of fractional indexing
@@ -467,10 +430,6 @@ describe('Operators', () => {
467430
graph.run()
468431

469432
const initialResult = tracker.getResult()
470-
console.log(
471-
`topK lexicographic initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
472-
)
473-
474433
expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
475434
expect(initialResult.messageCount).toBeLessThanOrEqual(6) // Should be efficient
476435

@@ -488,10 +447,6 @@ describe('Operators', () => {
488447
graph.run()
489448

490449
const update1Result = tracker.getResult()
491-
console.log(
492-
`topK lexicographic update1: ${update1Result.messageCount} messages, ${update1Result.sortedResults.length} final results`,
493-
)
494-
495450
// Should have efficient incremental update
496451
expect(update1Result.messageCount).toBeLessThanOrEqual(6) // Should be incremental
497452
expect(update1Result.messageCount).toBeGreaterThan(0) // Should have changes
@@ -510,20 +465,16 @@ describe('Operators', () => {
510465
graph.run()
511466

512467
const update2Result = tracker.getResult()
513-
console.log(
514-
`topK lexicographic update2: ${update2Result.messageCount} messages, ${update2Result.sortedResults.length} final results`,
515-
)
516-
517468
// Should have efficient incremental update for value changes
518469
expect(update2Result.messageCount).toBeLessThanOrEqual(6) // Should be incremental
519470
expect(update2Result.messageCount).toBeGreaterThan(0) // Should have changes
520471

521472
// Check that only the affected key produces messages
522-
const affectedKeys = new Set(
523-
update2Result.messages.map(([[key, _value], _mult]) => key),
473+
assertOnlyKeysAffected(
474+
'topK lexicographic update2',
475+
update2Result.messages,
476+
[null],
524477
)
525-
expect(affectedKeys.size).toBe(1)
526-
expect(affectedKeys.has(null)).toBe(true)
527478
})
528479

529480
it('should maintain correct order when cycling through multiple changes', () => {
@@ -555,10 +506,6 @@ describe('Operators', () => {
555506
graph.run()
556507

557508
const initialResult = tracker.getResult()
558-
console.log(
559-
`topK cycling initial: ${initialResult.messageCount} messages, ${initialResult.sortedResults.length} final results`,
560-
)
561-
562509
expect(initialResult.sortedResults.length).toBe(5) // Should have all 5 elements
563510
expect(initialResult.messageCount).toBeLessThanOrEqual(6) // Should be efficient
564511

@@ -586,10 +533,6 @@ describe('Operators', () => {
586533
graph.run()
587534

588535
const cycle1Result = tracker.getResult()
589-
console.log(
590-
`topK cycling update1: ${cycle1Result.messageCount} messages, ${cycle1Result.sortedResults.length} final results`,
591-
)
592-
593536
// Should have efficient incremental update
594537
expect(cycle1Result.messageCount).toBeLessThanOrEqual(4) // Should be incremental
595538
expect(cycle1Result.messageCount).toBeGreaterThan(0) // Should have changes
@@ -606,20 +549,14 @@ describe('Operators', () => {
606549
graph.run()
607550

608551
const cycle2Result = tracker.getResult()
609-
console.log(
610-
`topK cycling update2: ${cycle2Result.messageCount} messages, ${cycle2Result.sortedResults.length} final results`,
611-
)
612-
613552
// Should have efficient incremental update for the repositioning
614553
expect(cycle2Result.messageCount).toBeLessThanOrEqual(4) // Should be incremental
615554
expect(cycle2Result.messageCount).toBeGreaterThan(0) // Should have changes
616555

617556
// Check that only the affected key produces messages
618-
const affectedKeys = new Set(
619-
cycle2Result.messages.map(([[key, _value], _mult]) => key),
620-
)
621-
expect(affectedKeys.size).toBe(1)
622-
expect(affectedKeys.has(null)).toBe(true)
557+
assertOnlyKeysAffected('topK cycling update2', cycle2Result.messages, [
558+
null,
559+
])
623560

624561
// The key point is that the fractional indexing system can handle
625562
// multiple repositioning operations efficiently

‎packages/d2mini/tests/operators/topKWithIndex.test.ts‎

Lines changed: 6 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,11 @@ import { D2 } from '../../src/d2.js'
33
import { MultiSet } from '../../src/multiset.js'
44
import { output } from '../../src/operators/index.js'
55
import { topKWithIndex } from '../../src/operators/topK.js'
6-
import { MessageTracker, assertResults } from '../test-utils.js'
6+
import {
7+
MessageTracker,
8+
assertResults,
9+
assertOnlyKeysAffected,
10+
} from '../test-utils.js'
711

812
describe('Operators', () => {
913
describe('TopKWithIndex operation', () => {
@@ -211,10 +215,6 @@ describe('Operators', () => {
211215
// and that only the affected key (null) produces output
212216
const updateResult = tracker.getResult()
213217

214-
console.log(
215-
`topK after removing b: ${updateResult.messageCount} messages, ${updateResult.sortedResults.length} final results`,
216-
)
217-
218218
// Verify we got a reasonable number of messages (not the entire dataset)
219219
expect(updateResult.messageCount).toBeLessThanOrEqual(8) // Should be incremental, not full recompute
220220
expect(updateResult.messageCount).toBeGreaterThan(0) // Should have some changes
@@ -223,11 +223,7 @@ describe('Operators', () => {
223223
expect(updateResult.sortedResults.length).toBeGreaterThan(0)
224224

225225
// Check that the messages only affect the null key (verify incremental processing)
226-
const affectedKeys = new Set(
227-
updateResult.messages.map(([[key, _value], _mult]) => key),
228-
)
229-
expect(affectedKeys.size).toBe(1)
230-
expect(affectedKeys.has(null)).toBe(true)
226+
assertOnlyKeysAffected('topK remove row', updateResult.messages, [null])
231227
})
232228

233229
test('incremental update - adding rows that push existing rows out of limit window', () => {

0 commit comments

Comments
 (0)