Open History to see the last commit
1import { expect } from 'vitest'
2import { MultiSet } from '../src/multiset.js'
3
4// Enable detailed logging of test results when LOG_RESULTS is set
5const LOG_RESULTS =
6 process.env.LOG_RESULTS === `true` || process.env.LOG_RESULTS === `1`
7
8/**
9 * Materialize a result set from diff messages
10 * Takes an array of messages and consolidates them into a final result set
11 */
12export function materializeResults<T>(
13 messages: Array<[T, number]>,
14): Map<string, T> {
15 const multiSet = new MultiSet(messages)
16 const consolidated = multiSet.consolidate()
17 const result = new Map<string, T>()
18
19 for (const [item, multiplicity] of consolidated.getInner()) {
20 if (multiplicity > 0) {
21 // Use JSON.stringify for content-based key comparison
22 const key = JSON.stringify(item)
23 result.set(key, item)
24 }
25 }
26
27 return result
28}
29
30/**
31 * Materialize a keyed result set from diff messages
32 * Takes an array of keyed messages and consolidates them per key
33 */
34export function materializeKeyedResults<K, V>(
35 messages: Array<[[K, V], number]>,
36): Map<K, V> {
37 const result = new Map<K, Map<string, { value: V; multiplicity: number }>>()
38
39 // Group messages by key first
40 for (const [[key, value], multiplicity] of messages) {
41 if (!result.has(key)) {
42 result.set(key, new Map())
43 }
44
45 const valueMap = result.get(key)!
46 const valueKey = JSON.stringify(value)
47 const existing = valueMap.get(valueKey)
48 const newMultiplicity = (existing?.multiplicity ?? 0) + multiplicity
49
50 if (newMultiplicity === 0) {
51 valueMap.delete(valueKey)
52 } else {
53 valueMap.set(valueKey, { value, multiplicity: newMultiplicity })
54 }
55 }
56
57 // Extract final values per key
58 const finalResult = new Map<K, V>()
59 for (const [key, valueMap] of result.entries()) {
60 // Filter to only positive multiplicities
61 const positiveValues = Array.from(valueMap.values()).filter(
62 (entry) => entry.multiplicity > 0,
63 )
64
65 if (positiveValues.length === 1) {
66 finalResult.set(key, positiveValues[0].value)
67 } else if (positiveValues.length > 1) {
68 throw new Error(
69 `Key ${key} has multiple final values: ${positiveValues.map((v) => JSON.stringify(v.value)).join(`, `)}`,
70 )
71 }
72 // If no positive values, key was completely removed
73 }
74
75 return finalResult
76}
77
78/**
79 * Convert a Map back to a sorted array for comparison
80 */
81export function mapToSortedArray<T>(
82 map: Map<string, T>,
83 compare?: (a: T, b: T) => number,
84): Array<T> {
85 const compareFn =
86 compare ??
87 ((a: T, b: T) => {
88 // Sort by JSON string representation for consistent ordering
89 return JSON.stringify(a).localeCompare(JSON.stringify(b))
90 })
91 return Array.from(map.values()).sort(compareFn)
92}
93
94/**
95 * Create expected result set as a Map
96 */
97export function createExpectedResults<T>(items: Array<T>): Map<string, T> {
98 const map = new Map<string, T>()
99 for (const item of items) {
100 const key = JSON.stringify(item)
101 map.set(key, item)
102 }
103 return map
104}
105
106/**
107 * Test helper that tracks messages and materializes results
108 */
109export interface TestResult<T> {
110 messages: Array<[T, number]>
111 messageCount: number
112 materializedResults: Map<string, T>
113 sortedResults: Array<T>
114}
115
116export interface KeyedTestResult<K, V> {
117 messages: Array<[[K, V], number]>
118 messageCount: number
119 materializedResults: Map<K, V>
120 sortedResults: Array<[K, V]>
121}
122
123export class MessageTracker<T> {
124 private messages: Array<[T, number]> = []
125
126 addMessage(message: MultiSet<T>) {
127 this.messages.push(...message.getInner())
128 }
129
130 getResult(compare?: (a: T, b: T) => number): TestResult<T> {
131 const materializedResults = materializeResults(this.messages)
132 const sortedResults = mapToSortedArray(materializedResults, compare)
133
134 return {
135 messages: this.messages,
136 messageCount: this.messages.length,
137 materializedResults,
138 sortedResults,
139 }
140 }
141
142 reset() {
143 this.messages = []
144 }
145}
146
147export class KeyedMessageTracker<K, V> {
148 private messages: Array<[[K, V], number]> = []
149
150 addMessage(message: MultiSet<[K, V]>) {
151 this.messages.push(...message.getInner())
152 }
153
154 getResult(): KeyedTestResult<K, V> {
155 const materializedResults = materializeKeyedResults(this.messages)
156 const sortedResults = Array.from(materializedResults.entries()).sort(
157 (a, b) => {
158 // Sort by key for consistent ordering
159 return JSON.stringify(a[0]).localeCompare(JSON.stringify(b[0]))
160 },
161 )
162
163 return {
164 messages: this.messages,
165 messageCount: this.messages.length,
166 materializedResults,
167 sortedResults,
168 }
169 }
170
171 reset() {
172 this.messages = []
173 }
174}
175
176/**
177 * Assert that results match expected, with message count logging
178 */
179export function assertResults<T>(
180 testName: string,
181 actual: TestResult<T>,
182 expected: Array<T>,
183 maxExpectedMessages?: number,
184) {
185 const expectedMap = createExpectedResults(expected)
186 const expectedSorted = mapToSortedArray(expectedMap)
187
188 if (LOG_RESULTS) {
189 console.log(
190 `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results`,
191 )
192 console.log(` Messages:`, actual.messages)
193 console.log(` Final results:`, actual.sortedResults)
194 }
195
196 // Check that materialized results match expected
197 expect(actual.sortedResults).toEqual(expectedSorted)
198
199 // Check message count constraints if provided
200 if (maxExpectedMessages !== undefined) {
201 expect(actual.messageCount).toBeLessThanOrEqual(maxExpectedMessages)
202 }
203
204 // Log for debugging - use more reasonable threshold
205 // For empty results, allow up to 2 messages (typical for removal operations)
206 // For non-empty results, allow up to 3x the expected count
207 const reasonableThreshold = expected.length === 0 ? 2 : expected.length * 3
208 if (actual.messageCount > reasonableThreshold) {
209 console.warn(
210 `⚠️ ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected results)`,
211 )
212 }
213}
214
215/**
216 * Assert that keyed results match expected, with message count logging
217 */
218export function assertKeyedResults<K, V>(
219 testName: string,
220 actual: KeyedTestResult<K, V>,
221 expected: Array<[K, V]>,
222 maxExpectedMessages?: number,
223) {
224 const expectedSorted = expected.sort((a, b) => {
225 return JSON.stringify(a[0]).localeCompare(JSON.stringify(b[0]))
226 })
227
228 if (LOG_RESULTS) {
229 console.log(
230 `${testName}: ${actual.messageCount} messages, ${actual.sortedResults.length} final results per key`,
231 )
232 console.log(` Messages:`, actual.messages)
233 console.log(` Final results:`, actual.sortedResults)
234 }
235
236 // Check that materialized results match expected
237 expect(actual.sortedResults).toEqual(expectedSorted)
238
239 // Check message count constraints if provided
240 if (maxExpectedMessages !== undefined) {
241 expect(actual.messageCount).toBeLessThanOrEqual(maxExpectedMessages)
242 }
243
244 // Log for debugging - use more reasonable threshold
245 // Account for scenarios where messages cancel out due to object identity
246 // Allow up to 4x the expected count to accommodate remove/add pairs
247 const reasonableThreshold = Math.max(expected.length * 4, 2)
248 if (actual.messageCount > reasonableThreshold) {
249 console.warn(
250 `⚠️ ${testName}: High message count (${actual.messageCount} messages for ${expected.length} expected key-value pairs)`,
251 )
252 }
253
254 // Log key insights
255 const affectedKeys = new Set(
256 actual.messages.map(([[key, _value], _mult]) => key),
257 )
258 if (LOG_RESULTS) {
259 console.log(
260 `${testName}: ✅ ${affectedKeys.size} keys affected, ${actual.sortedResults.length} final keys`,
261 )
262 }
263}
264
265/**
266 * Extract unique keys from messages to verify incremental behavior
267 */
268export function extractMessageKeys<K, V>(
269 messages: Array<[[K, V], number]>,
270): Set<K> {
271 const keys = new Set<K>()
272 for (const [[key, _value], _multiplicity] of messages) {
273 keys.add(key)
274 }
275 return keys
276}
277
278/**
279 * Assert that only specific keys appear in messages (for incremental processing verification)
280 */
281export function assertOnlyKeysAffected<K, V>(
282 testName: string,
283 messages: Array<[[K, V], number]>,
284 expectedKeys: Array<K>,
285) {
286 const actualKeys = extractMessageKeys(messages)
287 const expectedKeySet = new Set(expectedKeys)
288
289 // Check that all actual keys are expected
290 Array.from(actualKeys).forEach((key) => {
291 if (!expectedKeySet.has(key)) {
292 throw new Error(`${testName}: Unexpected key ${key} in messages`)
293 }
294 })
295
296 if (LOG_RESULTS) {
297 console.log(
298 `${testName}: ✅ Only expected keys affected: ${Array.from(actualKeys).join(`, `)}`,
299 )
300 }
301}
302
303export const compareFractionalIndex = (
304 r1: [unknown, [unknown, string]],
305 r2: [unknown, [unknown, string]],
306) => {
307 const [_key1, [_value1, index1]] = r1
308 const [_key2, [_value2, index2]] = r2
309 return index1 < index2 ? -1 : index1 > index2 ? 1 : 0
310}