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