Skip to content
Source
Sign inSign up
TanStack/db
Open History to see the last commit

conformance.test.ts

406 lines11.5 KB

1/**
2 * Angular driver for the shared live-query conformance suite.
3 *
4 * `injectLiveQuery` needs an injection context, so each mount runs inside a
5 * child `EnvironmentInjector` created off TestBed's; `unmount` calls
6 * `injector.destroy()`, firing the `DestroyRef` cleanup. Result signals are read
7 * after settling. Controllable inputs use Angular's reactive `{ params, query }`
8 * form driven by a signal.
9 *
10 * All registered laws must pass; the driver has no whole-test waivers.
11 */
12import { describe, expect, it } from 'vitest'
13import {
14 Component,
15 DestroyRef,
16 EnvironmentInjector,
17 createEnvironmentInjector,
18 inject,
19 input,
20 runInInjectionContext,
21 signal,
22} from '@angular/core'
23import { TestBed } from '@angular/core/testing'
24import {
25 coalesce,
26 count,
27 createCollection,
28 createLiveQueryCollection,
29 createOptimisticAction,
30 eq,
31 gt,
32 sum,
33} from '@tanstack/db'
34import {
35 mockSyncCollectionOptions,
36 mockSyncCollectionOptionsNoInitialState,
37} from '../../db/tests/utils'
38import { injectLiveQuery } from '../src/index'
39import { runSuite } from '../../db/tests/conformance/suite'
40import { expectResultSurface } from '../../db/tests/conformance/result-laws'
41import { withScopeSetup } from '../../db/tests/conformance/scope-setup'
42import type {
43 ConformanceResult,
44 ControllableHandle,
45 DeferredSourceHandle,
46 LiveQueryDriver,
47 LiveQueryHandle,
48 QueryBuild,
49 SourceHandle,
50} from '../../db/tests/conformance/contract'
51​
52let sourceSeq = 0
53​
54function writer<T extends { id: string }>(collection: any) {
55 return (type: `insert` | `update` | `delete`, value: T) => {
56 collection.utils.begin()
57 collection.utils.write({ type, value })
58 collection.utils.commit()
59 }
61​
62function makeSource<T extends { id: string }>(
63 initialData: ReadonlyArray<T>,
64): SourceHandle<T> {
65 const collection = createCollection(
66 mockSyncCollectionOptions<T>({
67 id: `conformance-angular-${sourceSeq++}`,
68 getKey: (r) => r.id,
69 initialData: [...initialData],
70 }),
71 )
72 const write = writer<T>(collection)
73 return {
74 collection,
75 insert: (row) => write(`insert`, row),
76 update: (row) => write(`update`, row),
77 remove: (row) => write(`delete`, row),
78 }
80​
81function makeDeferredSource<
82 T extends { id: string },
83>(): DeferredSourceHandle<T> {
84 const collection = createCollection(
85 mockSyncCollectionOptionsNoInitialState<T>({
86 id: `conformance-angular-${sourceSeq++}`,
87 getKey: (r) => r.id,
88 }),
89 )
90 collection.startSyncImmediate()
91 const write = writer<T>(collection)
92 return {
93 collection,
94 insert: (row) => write(`insert`, row),
95 update: (row) => write(`update`, row),
96 remove: (row) => write(`delete`, row),
97 emit: (rows) => {
98 collection.utils.begin()
99 rows.forEach((value) => collection.utils.write({ type: `insert`, value }))
100 collection.utils.commit()
101 },
102 markReady: () => collection.utils.markReady(),
103 }
105​
106function makePrecreated(build: QueryBuild, opts?: { startSync?: boolean }) {
107 const collection = createLiveQueryCollection({
108 query: build as any,
109 startSync: opts?.startSync ?? true,
110 })
111 return { collection }
113​
114function makeErrorSource() {
115 const expectedError = new Error(`conformance: sync failure`)
116 let startup: { returned: true } | { returned: false; error: unknown } = {
117 returned: true,
118 }
119 const collection = createCollection<{ id: string }>({
120 id: `conformance-angular-err-${sourceSeq++}`,
121 getKey: (r) => r.id,
122 startSync: false,
123 sync: {
124 sync: () => {
125 throw expectedError
126 },
127 },
128 })
129 try {
130 collection.startSyncImmediate()
131 } catch (error) {
132 startup = { returned: false, error }
133 }
134 return { collection, expectedError, startup }
136​
137async function settle() {
138 await new Promise((resolve) => setTimeout(resolve, 0))
139 await new Promise((resolve) => setTimeout(resolve, 50))
141​
142function makeHandle(result: any, destroy: () => void): LiveQueryHandle {
143 return {
144 current(): ConformanceResult {
145 return expectResultSurface({
146 data: result.data(),
147 state: result.state(),
148 status: result.status(),
149 isReady: result.isReady(),
150 persistedStatus: result.persistedStatus(),
151 isPersistedReady: result.isPersistedReady(),
152 persistedError: result.persistedError(),
153 isError: result.isError(),
154 // angular-db exposes no `isEnabled`; derive it from status (status-derived).
155 isEnabled: result.status() !== `disabled`,
156 })
157 },
158 flush: settle,
159 async apply(fn: () => void) {
160 fn()
161 await settle()
162 },
163 unmount() {
164 destroy()
165 },
166 }
168​
169function inCtx(fn: () => any): { result: any; destroy: () => void } {
170 const parent = TestBed.inject(EnvironmentInjector)
171 const injector = createEnvironmentInjector([], parent)
172 let result: any
173 withScopeSetup(
174 () =>
175 runInInjectionContext(injector, () => {
176 result = fn()
177 }),
178 () => injector.destroy(),
179 )
180 return { result, destroy: () => injector.destroy() }
182​
183function mount(build: QueryBuild) {
184 const { result, destroy } = inCtx(() => injectLiveQuery(build as any))
185 return makeHandle(result, destroy)
187​
188function mountCollection(collection: any) {
189 const { result, destroy } = inCtx(() => injectLiveQuery(collection))
190 return makeHandle(result, destroy)
192​
193function mountConfig(build: QueryBuild) {
194 const { result, destroy } = inCtx(() => injectLiveQuery({ query: build }))
195 return makeHandle(result, destroy)
197​
198function mountDisabled() {
199 const { result, destroy } = inCtx(() => injectLiveQuery(() => null))
200 return makeHandle(result, destroy)
202​
203function mountControllable<P>(
204 build: (q: any, param: P) => any,
205 initial: P,
206): ControllableHandle<P> {
207 const param = signal<P>(initial)
208 const { result, destroy } = inCtx(() =>
209 injectLiveQuery({
210 params: () => ({ value: param() }),
211 query: ({ params, q }: any) => build(q, params.value),
212 }),
213 )
214 const handle = makeHandle(result, destroy)
215 return {
216 ...handle,
217 async setParam(next: P) {
218 param.set(next)
219 await settle()
220 },
221 }
223​
224const angularDriver: LiveQueryDriver = {
225 name: `angular`,
226 disabledRepresentation: `empty-reactive`,
227 ops: { eq, gt, count, sum, coalesce, createOptimisticAction },
228 makeSource,
229 makeDeferredSource,
230 makePrecreated,
231 makeErrorSource,
232 mount,
233 mountControllable,
234 mountCollection,
235 mountConfig,
236 mountDisabled,
237 knownGaps: [],
238 features: { serverSnapshot: false, suspense: false, pooledEqFilters: true },
240​
241describe(`owned native scope setup`, () => {
242 it(`keeps a successful scope alive until explicit disposal`, () => {
243 let calls = 0
244 const handle = inCtx(() => {
245 inject(DestroyRef).onDestroy(() => {
246 calls++
247 })
248 return 7
249 })
250 expect(calls).toBe(0)
251 handle.destroy()
252 expect(calls).toBe(1)
253 })
254​
255 it.each([false, true])(
256 `disposes failed setup and retains errors, cleanupFails=%s`,
257 (cleanupFails) => {
258 const primary = new Error(`scope setup failure`)
259 const secondary = new Error(`scope cleanup failure`)
260 let calls = 0
261 let caught: unknown
262 try {
263 inCtx(() => {
264 inject(DestroyRef).onDestroy(() => {
265 calls++
266 if (cleanupFails) throw secondary
267 })
268 throw primary
269 })
270 } catch (error) {
271 caught = error
272 }
273 expect(calls).toBe(1)
274 if (cleanupFails) {
275 expect(caught).toBeInstanceOf(AggregateError)
276 expect((caught as AggregateError).errors).toEqual([primary, secondary])
277 expect((caught as AggregateError).cause).toBe(primary)
278 } else expect(caught).toBe(primary)
279 },
280 )
281})
282​
283runSuite(angularDriver)
284​
285it(`reports a disabled query as ready before effects run`, () => {
286 const mounted = inCtx(() => injectLiveQuery(() => null))
287 try {
288 expect(mounted.result.status()).toBe(`disabled`)
289 expect(mounted.result.isReady()).toBe(true)
290 } finally {
291 mounted.destroy()
292 }
293})
294​
295/**
296 * Angular component boundary: required inputs are assigned after field
297 * initialization. A reactive live-query option may read an input when Angular
298 * first runs effects, but construction must not read it before `setInput`.
299 * The model is a full filter of two fixed source rows at each input value.
300 * This checks rendered public data after change detection, not every possible
301 * framework scheduling cut or the shared query model's other laws.
302 */
303it(`waits for required inputs before evaluating a reactive live query`, async () => {
304 const source = createCollection(
305 mockSyncCollectionOptions<{ id: string; age: number }>({
306 id: `angular-required-input-query`,
307 getKey: (row) => row.id,
308 initialData: [
309 { id: `a`, age: 20 },
310 { id: `b`, age: 40 },
311 ],
312 }),
313 )
314​
315 @Component({
316 inputs: [{ name: `minAge`, required: true }],
317 template: `{{ live.data().length }}`,
318 })
319 class RequiredInputQuery {
320 minAge = input.required<number>()
321 live = injectLiveQuery({
322 params: () => ({ minAge: this.minAge() }),
323 query: ({ params, q }) =>
324 q
325 .from({ person: source })
326 .where(({ person }) => gt(person.age, params.minAge))
327 .select(({ person }) => ({ id: person.id, age: person.age })),
328 })
329 }
330​
331 // This suite uses Angular's JIT test environment, which does not infer the
332 // signal-input flag from `input.required()`. Supply the same input metadata
333 // that Angular's AOT compiler emits; TestBed still constructs the component,
334 // assigns the input, runs its effects, and renders the public result.
335 const definition = (
336 RequiredInputQuery as unknown as {
337 ɵcmp: { inputs: { minAge: [string, number, null] } }
338 }
339 ).ɵcmp
340 definition.inputs.minAge = [`minAge`, 1, null]
341​
342 const fixture = TestBed.createComponent(RequiredInputQuery)
343 try {
344 fixture.componentRef.setInput(`minAge`, 30)
345 fixture.detectChanges()
346 await settle()
347 fixture.detectChanges()
348 expect(fixture.nativeElement.textContent.trim()).toBe(`1`)
349 expect(fixture.componentInstance.live.data().map((row) => row.id)).toEqual([
350 `b`,
351 ])
352​
353 fixture.componentRef.setInput(`minAge`, 10)
354 fixture.detectChanges()
355 await settle()
356 fixture.detectChanges()
357 expect(fixture.nativeElement.textContent.trim()).toBe(`2`)
358 expect(fixture.componentInstance.live.data().map((row) => row.id)).toEqual([
359 `a`,
360 `b`,
361 ])
362 } finally {
363 fixture.destroy()
364 }
365})
366​
367it(`preserves raw result types through the actual driver reader`, () => {
368 const raw: Record<string, unknown> = {
369 data: [{ id: `a`, value: undefined }],
370 state: new Map(),
371 status: `disabled`,
372 isReady: false,
373 persistedStatus: `unavailable`,
374 isPersistedReady: false,
375 persistedError: undefined,
376 isError: false,
377 isEnabled: false,
378 }
379 const result = Object.fromEntries(
380 Object.keys(raw).map((key) => [key, () => raw[key]]),
381 )
382 const handle = makeHandle(result, () => {})
383 try {
384 const healthy = handle.current()
385 expect(healthy.data).toBe(raw.data)
386 expect(healthy.state).toBe(raw.state)
387 expect(healthy.isReady).toBe(false)
388 expect(healthy.isError).toBe(false)
389 expect(healthy.isEnabled).toBe(false)
390 for (const key of [`status`, `isReady`, `isError`]) {
391 const original = raw[key]
392 delete raw[key]
393 expect(() => handle.current()).toThrowError(new RegExp(`raw ${key}`))
394 for (const invalid of key === `status`
395 ? [undefined, 0]
396 : [undefined, 0, ``]) {
397 raw[key] = invalid
398 expect(() => handle.current()).toThrowError(new RegExp(`raw ${key}`))
399 }
400 raw[key] = original
401 expect(handle.current()[key as keyof ConformanceResult]).toBe(original)
402 }
403 } finally {
404 handle.unmount()
405 }
406})