Open History to see the last commit
1import { describe, expect, it, vi } from 'vitest'
2import { act, renderHook, waitFor } from '@testing-library/react'
3import {
4 DbClient,
5 collectionOptions,
6 createCollection,
7 createLiveQueryCollection,
8 eq,
9 getStableValueHash,
10 gt,
11} from '@tanstack/db'
12import { StrictMode, Suspense } from 'react'
13import { useLiveSuspenseQuery } from '../src/useLiveSuspenseQuery'
14import { DbProvider } from '../src/DbProvider'
15import { mockSyncCollectionOptions } from '../../db/tests/utils'
16import type { ReactNode } from 'react'
17
18type Person = {
19 id: string
20 name: string
21 age: number
22 email: string
23 isActive: boolean
24 team: string
25}
26
27const initialPersons: Array<Person> = [
28 {
29 id: `1`,
30 name: `John Doe`,
31 age: 30,
32 email: `john.doe@example.com`,
33 isActive: true,
34 team: `team1`,
35 },
36 {
37 id: `2`,
38 name: `Jane Doe`,
39 age: 25,
40 email: `jane.doe@example.com`,
41 isActive: true,
42 team: `team2`,
43 },
44 {
45 id: `3`,
46 name: `John Smith`,
47 age: 35,
48 email: `john.smith@example.com`,
49 isActive: true,
50 team: `team1`,
51 },
52]
53
54// Wrapper component with Suspense
55function SuspenseWrapper({ children }: { children: ReactNode }) {
56 return <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
57}
58
59describe(`useLiveSuspenseQuery`, () => {
60 it(`renders a streamed query snapshot until browser sync is authoritative`, async () => {
61 let resolveServerLoad!: () => void
62 const serverLoad = new Promise<void>((resolve) => {
63 resolveServerLoad = resolve
64 })
65 let resolveBrowserLoad!: () => void
66 let finishBrowserLoad!: () => void
67 const browserLoadPromise = new Promise<void>((resolve) => {
68 finishBrowserLoad = resolve
69 })
70 const browserLoad = vi.fn()
71 const descriptor = collectionOptions(`streamed-people`, (client) => {
72 const runtime = client.requireDependency<`server` | `browser`>(`runtime`)
73
74 return {
75 id: `streamed-people`,
76 getKey: (person: Person) => person.id,
77 syncMode: `on-demand` as const,
78 sync: {
79 sync: ({ begin, write, commit, markReady }) => {
80 markReady()
81 return {
82 loadSubset:
83 runtime === `server`
84 ? async () => {
85 await serverLoad
86 begin({ immediate: true })
87 write({ type: `insert`, value: initialPersons[0]! })
88 commit()
89 }
90 : () => {
91 browserLoad()
92 resolveBrowserLoad = () => {
93 begin({ immediate: true })
94 write({
95 type: `insert`,
96 value: initialPersons[1]!,
97 })
98 commit()
99 finishBrowserLoad()
100 }
101 return browserLoadPromise
102 },
103 }
104 },
105 },
106 }
107 })
108 const serverClient = new DbClient({ runtime: `server` })
109 serverClient._setSsrStreamingEnabled(true)
110 const serverWrapper = ({ children }: { children: ReactNode }) => (
111 <DbProvider client={serverClient}>
112 <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
113 </DbProvider>
114 )
115 const serverHook = renderHook(
116 () =>
117 useLiveSuspenseQuery({
118 query: (q) => q.from({ people: descriptor }),
119 }),
120 { wrapper: serverWrapper },
121 )
122
123 const dehydrated = serverClient.dehydrate({
124 shouldDehydrateCollection: () => false,
125 shouldDehydrateLiveQuery: () => true,
126 })
127 const dehydratedQuery = dehydrated.liveQueries?.[0]
128 expect(dehydratedQuery).toBeDefined()
129
130 const browserClient = new DbClient({ runtime: `browser` })
131 browserClient._setSsrStreamingEnabled(true)
132 browserClient.hydrate(dehydrated)
133 const browserWrapper = ({ children }: { children: ReactNode }) => (
134 <DbProvider client={browserClient}>
135 <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
136 </DbProvider>
137 )
138 const browserHook = renderHook(
139 () =>
140 useLiveSuspenseQuery({
141 query: (q) => q.from({ people: descriptor }),
142 }),
143 { wrapper: browserWrapper },
144 )
145
146 expect(browserLoad).not.toHaveBeenCalled()
147
148 await act(async () => {
149 resolveServerLoad()
150 await browserClient._getLiveQuery(dehydratedQuery!.queryHash)?.promise
151 })
152
153 await waitFor(() => {
154 expect(browserHook.result.current.data).toHaveLength(1)
155 expect(browserHook.result.current.data[0]).toMatchObject(
156 initialPersons[0]!,
157 )
158 })
159 expect(browserLoad).toHaveBeenCalled()
160
161 await act(async () => resolveBrowserLoad())
162
163 await waitFor(() => {
164 expect(browserHook.result.current.data).toHaveLength(1)
165 expect(browserHook.result.current.data[0]).toMatchObject(
166 initialPersons[1]!,
167 )
168 })
169 serverHook.unmount()
170 browserHook.unmount()
171 })
172
173 it(`requires queryKey for an opaque query during SSR streaming`, () => {
174 const warn = vi.spyOn(console, `warn`).mockImplementation(() => {})
175 const descriptor = collectionOptions(`streamed-people`, () => ({
176 id: `streamed-people`,
177 getKey: (person: Person) => person.id,
178 syncMode: `on-demand` as const,
179 sync: {
180 sync: ({ markReady }) => {
181 markReady()
182 return { loadSubset: () => new Promise<void>(() => {}) }
183 },
184 },
185 }))
186 const client = new DbClient()
187 client._setSsrStreamingEnabled(true)
188 const wrapper = ({ children }: { children: ReactNode }) => (
189 <DbProvider client={client}>{children}</DbProvider>
190 )
191
192 expect(() =>
193 renderHook(
194 () =>
195 useLiveSuspenseQuery({
196 query: (q) =>
197 q
198 .from({ people: descriptor })
199 .fn.where(({ people }) => people.age > 20),
200 }),
201 { wrapper },
202 ),
203 ).toThrow(/Provide an explicit serializable queryKey/)
204 expect(warn).toHaveBeenCalledWith(
205 expect.stringContaining(`cannot derive a stable identity`),
206 )
207 warn.mockRestore()
208 })
209
210 it(`throws the original streamed query error`, async () => {
211 const error = new Error(`Server load failed`)
212 const queryKey = [`streamed-people-error`] as const
213 const queryHash = getStableValueHash([`queryKey`, queryKey], `queryKey`)
214 const descriptor = collectionOptions(`streamed-people-error`, () => ({
215 id: `streamed-people-error`,
216 getKey: (person: Person) => person.id,
217 syncMode: `on-demand` as const,
218 sync: {
219 sync: ({ markReady }) => {
220 markReady()
221 return { loadSubset: () => new Promise<void>(() => {}) }
222 },
223 },
224 }))
225 const client = new DbClient()
226 client._setSsrStreamingEnabled(true)
227 await expect(
228 client._registerLiveQuery(queryHash, Promise.reject(error)),
229 ).rejects.toBe(error)
230 const wrapper = ({ children }: { children: ReactNode }) => (
231 <DbProvider client={client}>{children}</DbProvider>
232 )
233 const consoleError = vi.spyOn(console, `error`).mockImplementation(() => {})
234
235 expect(() =>
236 renderHook(
237 () =>
238 useLiveSuspenseQuery({
239 queryKey,
240 query: (q) => q.from({ people: descriptor }),
241 }),
242 { wrapper },
243 ),
244 ).toThrow(error)
245
246 consoleError.mockRestore()
247 })
248
249 it(`should suspend while loading and return data when ready`, async () => {
250 const collection = createCollection(
251 mockSyncCollectionOptions<Person>({
252 id: `test-persons-suspense-1`,
253 getKey: (person: Person) => person.id,
254 initialData: initialPersons,
255 }),
256 )
257
258 const { result } = renderHook(
259 () => {
260 return useLiveSuspenseQuery((q) =>
261 q
262 .from({ persons: collection })
263 .where(({ persons }) => gt(persons.age, 30))
264 .select(({ persons }) => ({
265 id: persons.id,
266 name: persons.name,
267 age: persons.age,
268 })),
269 )
270 },
271 {
272 wrapper: SuspenseWrapper,
273 },
274 )
275
276 // Wait for data to load
277 await waitFor(() => {
278 expect(result.current.state.size).toBe(1)
279 })
280
281 expect(result.current.data).toHaveLength(1)
282 const johnSmith = result.current.data[0]
283 expect(johnSmith).toMatchObject({
284 id: `3`,
285 name: `John Smith`,
286 age: 35,
287 })
288 })
289
290 it(`should return data that is always defined (type-safe)`, async () => {
291 const collection = createCollection(
292 mockSyncCollectionOptions<Person>({
293 id: `test-persons-suspense-2`,
294 getKey: (person: Person) => person.id,
295 initialData: initialPersons,
296 }),
297 )
298
299 const { result } = renderHook(
300 () => {
301 return useLiveSuspenseQuery((q) => q.from({ persons: collection }))
302 },
303 {
304 wrapper: SuspenseWrapper,
305 },
306 )
307
308 await waitFor(() => {
309 expect(result.current.data).toBeDefined()
310 })
311
312 // Data is always defined - no optional chaining needed
313 expect(result.current.data.length).toBe(3)
314 // TypeScript will guarantee data is Array<Person>, not Array<Person> | undefined
315 })
316
317 it(`should work with single result queries`, async () => {
318 const collection = createCollection(
319 mockSyncCollectionOptions<Person>({
320 id: `test-persons-suspense-3`,
321 getKey: (person: Person) => person.id,
322 initialData: initialPersons,
323 }),
324 )
325
326 const { result } = renderHook(
327 () => {
328 return useLiveSuspenseQuery((q) =>
329 q
330 .from({ collection })
331 .where(({ collection: c }) => eq(c.id, `3`))
332 .findOne(),
333 )
334 },
335 {
336 wrapper: SuspenseWrapper,
337 },
338 )
339
340 await waitFor(() => {
341 expect(result.current.state.size).toBe(1)
342 })
343
344 expect(result.current.data).toMatchObject({
345 id: `3`,
346 name: `John Smith`,
347 age: 35,
348 })
349 })
350
351 it(`should work with pre-created live query collection`, async () => {
352 const collection = createCollection(
353 mockSyncCollectionOptions<Person>({
354 id: `test-persons-suspense-4`,
355 getKey: (person: Person) => person.id,
356 initialData: initialPersons,
357 }),
358 )
359
360 const liveQuery = createLiveQueryCollection((q) =>
361 q
362 .from({ persons: collection })
363 .where(({ persons }) => gt(persons.age, 30)),
364 )
365
366 const { result } = renderHook(() => useLiveSuspenseQuery(liveQuery), {
367 wrapper: SuspenseWrapper,
368 })
369
370 await waitFor(() => {
371 expect(result.current.data).toHaveLength(1)
372 })
373
374 expect(result.current.data[0]).toMatchObject({
375 id: `3`,
376 name: `John Smith`,
377 age: 35,
378 })
379 })
380
381 it(`should re-suspend when derived query identity changes`, async () => {
382 const collection = createCollection(
383 mockSyncCollectionOptions<Person>({
384 id: `test-persons-suspense-5`,
385 getKey: (person: Person) => person.id,
386 initialData: initialPersons,
387 }),
388 )
389
390 const { result, rerender } = renderHook(
391 ({ minAge }) => {
392 return useLiveSuspenseQuery({
393 query: (q) =>
394 q
395 .from({ persons: collection })
396 .where(({ persons }) => gt(persons.age, minAge)),
397 })
398 },
399 {
400 wrapper: SuspenseWrapper,
401 initialProps: { minAge: 30 },
402 },
403 )
404
405 // Initial load - age > 30
406 await waitFor(() => {
407 expect(result.current.data).toHaveLength(1)
408 })
409 expect(result.current.data[0]?.age).toBe(35)
410
411 // Change derived identity - age > 20
412 rerender({ minAge: 20 })
413
414 // Should re-suspend and load new data
415 await waitFor(() => {
416 expect(result.current.data).toHaveLength(3)
417 })
418 })
419
420 it(`should reactively update data after initial load`, async () => {
421 const collection = createCollection(
422 mockSyncCollectionOptions<Person>({
423 id: `test-persons-suspense-6`,
424 getKey: (person: Person) => person.id,
425 initialData: initialPersons,
426 }),
427 )
428
429 const { result } = renderHook(
430 () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
431 {
432 wrapper: SuspenseWrapper,
433 },
434 )
435
436 // Wait for initial data
437 await waitFor(() => {
438 expect(result.current.data).toHaveLength(3)
439 })
440
441 // Insert new person
442 collection.insert({
443 id: `4`,
444 name: `New Person`,
445 age: 40,
446 email: `new@example.com`,
447 isActive: true,
448 team: `team1`,
449 })
450
451 // Should reactively update
452 await waitFor(() => {
453 expect(result.current.data).toHaveLength(4)
454 })
455 })
456
457 it(`should throw error when query function returns undefined`, () => {
458 expect(() => {
459 renderHook(
460 () => {
461 return useLiveSuspenseQuery(() => undefined as any)
462 },
463 {
464 wrapper: SuspenseWrapper,
465 },
466 )
467 }).toThrow(/does not support disabled queries/)
468 })
469
470 it(`should work with config object`, async () => {
471 const collection = createCollection(
472 mockSyncCollectionOptions<Person>({
473 id: `test-persons-suspense-7`,
474 getKey: (person: Person) => person.id,
475 initialData: initialPersons,
476 }),
477 )
478
479 const { result } = renderHook(
480 () => {
481 return useLiveSuspenseQuery({
482 query: (q) => q.from({ persons: collection }),
483 })
484 },
485 {
486 wrapper: SuspenseWrapper,
487 },
488 )
489
490 await waitFor(() => {
491 expect(result.current.data).toHaveLength(3)
492 })
493 })
494
495 it(`should keep stable data references when data hasn't changed`, async () => {
496 const collection = createCollection(
497 mockSyncCollectionOptions<Person>({
498 id: `test-persons-suspense-8`,
499 getKey: (person: Person) => person.id,
500 initialData: initialPersons,
501 }),
502 )
503
504 const { result, rerender } = renderHook(
505 () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
506 {
507 wrapper: SuspenseWrapper,
508 },
509 )
510
511 await waitFor(() => {
512 expect(result.current.data).toHaveLength(3)
513 })
514
515 const data1 = result.current.data
516
517 rerender()
518
519 const data2 = result.current.data
520
521 // Data objects should be stable
522 expect(data1[0]).toBe(data2[0])
523 expect(data1[1]).toBe(data2[1])
524 expect(data1[2]).toBe(data2[2])
525 })
526
527 it(`should handle multiple queries in same component (serial execution)`, async () => {
528 const personsCollection = createCollection(
529 mockSyncCollectionOptions<Person>({
530 id: `test-persons-suspense-9`,
531 getKey: (person: Person) => person.id,
532 initialData: initialPersons,
533 }),
534 )
535
536 const { result } = renderHook(
537 () => {
538 const persons = useLiveSuspenseQuery((q) =>
539 q.from({ persons: personsCollection }),
540 )
541 const johnDoe = useLiveSuspenseQuery((q) =>
542 q
543 .from({ persons: personsCollection })
544 .where(({ persons: p }) => eq(p.id, `1`))
545 .findOne(),
546 )
547 return { persons, johnDoe }
548 },
549 {
550 wrapper: SuspenseWrapper,
551 },
552 )
553
554 await waitFor(() => {
555 expect(result.current.persons.data).toHaveLength(3)
556 expect(result.current.johnDoe.data).toBeDefined()
557 })
558
559 expect(result.current.johnDoe.data).toMatchObject({
560 id: `1`,
561 name: `John Doe`,
562 })
563 })
564
565 it(`should cleanup collection when unmounted`, async () => {
566 const collection = createCollection(
567 mockSyncCollectionOptions<Person>({
568 id: `test-persons-suspense-10`,
569 getKey: (person: Person) => person.id,
570 initialData: initialPersons,
571 }),
572 )
573
574 const { result, unmount } = renderHook(
575 () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
576 {
577 wrapper: SuspenseWrapper,
578 },
579 )
580
581 await waitFor(() => {
582 expect(result.current.data).toHaveLength(3)
583 })
584
585 const liveQueryCollection = result.current.collection
586 expect(liveQueryCollection.subscriberCount).toBeGreaterThan(0)
587
588 unmount()
589
590 // Collection should eventually be cleaned up (gcTime is 1ms)
591 await waitFor(
592 () => {
593 expect(liveQueryCollection.status).toBe(`cleaned-up`)
594 },
595 { timeout: 1000 },
596 )
597 })
598
599 it(`should NOT re-suspend on live updates after initial load`, async () => {
600 const collection = createCollection(
601 mockSyncCollectionOptions<Person>({
602 id: `test-persons-suspense-11`,
603 getKey: (person: Person) => person.id,
604 initialData: initialPersons,
605 }),
606 )
607
608 let suspenseCount = 0
609 const SuspenseCounter = ({ children }: { children: ReactNode }) => {
610 return (
611 <Suspense
612 fallback={
613 <div>
614 {(() => {
615 suspenseCount++
616 return `Loading...`
617 })()}
618 </div>
619 }
620 >
621 {children}
622 </Suspense>
623 )
624 }
625
626 const { result } = renderHook(
627 () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
628 {
629 wrapper: SuspenseCounter,
630 },
631 )
632
633 // Wait for initial load
634 await waitFor(() => {
635 expect(result.current.data).toHaveLength(3)
636 })
637
638 const initialSuspenseCount = suspenseCount
639
640 // Make multiple live updates
641 collection.insert({
642 id: `4`,
643 name: `New Person 1`,
644 age: 40,
645 email: `new1@example.com`,
646 isActive: true,
647 team: `team1`,
648 })
649
650 await waitFor(() => {
651 expect(result.current.data).toHaveLength(4)
652 })
653
654 collection.insert({
655 id: `5`,
656 name: `New Person 2`,
657 age: 45,
658 email: `new2@example.com`,
659 isActive: true,
660 team: `team2`,
661 })
662
663 await waitFor(() => {
664 expect(result.current.data).toHaveLength(5)
665 })
666
667 collection.delete(`4`)
668
669 await waitFor(() => {
670 expect(result.current.data).toHaveLength(4)
671 })
672
673 // Verify suspense count hasn't increased (no re-suspension)
674 expect(suspenseCount).toBe(initialSuspenseCount)
675 })
676
677 it(`should only suspend on deps change, not on every re-render`, async () => {
678 const collection = createCollection(
679 mockSyncCollectionOptions<Person>({
680 id: `test-persons-suspense-12`,
681 getKey: (person: Person) => person.id,
682 initialData: initialPersons,
683 }),
684 )
685
686 const { result, rerender } = renderHook(
687 ({ minAge }) =>
688 useLiveSuspenseQuery(
689 (q) =>
690 q
691 .from({ persons: collection })
692 .where(({ persons }) => gt(persons.age, minAge)),
693 [minAge],
694 ),
695 {
696 wrapper: SuspenseWrapper,
697 initialProps: { minAge: 20 },
698 },
699 )
700
701 // Wait for initial load
702 await waitFor(() => {
703 expect(result.current.data).toHaveLength(3)
704 })
705
706 const dataAfterInitial = result.current.data
707
708 // Re-render with SAME deps - should NOT suspend (data stays available)
709 rerender({ minAge: 20 })
710 expect(result.current.data).toHaveLength(3)
711 expect(result.current.data).toBe(dataAfterInitial)
712
713 rerender({ minAge: 20 })
714 expect(result.current.data).toHaveLength(3)
715
716 rerender({ minAge: 20 })
717 expect(result.current.data).toHaveLength(3)
718
719 // Change deps - SHOULD suspend and get new data
720 rerender({ minAge: 30 })
721
722 await waitFor(() => {
723 expect(result.current.data).toHaveLength(1)
724 })
725
726 expect(result.current.data[0]?.age).toBe(35)
727 })
728
729 it(`should work with pre-created SingleResult collection`, async () => {
730 const collection = createCollection(
731 mockSyncCollectionOptions<Person>({
732 id: `test-persons-suspense-single`,
733 getKey: (person: Person) => person.id,
734 initialData: initialPersons,
735 }),
736 )
737
738 // Pre-create a SingleResult live query collection
739 const singlePersonQuery = createLiveQueryCollection((q) =>
740 q
741 .from({ persons: collection })
742 .where(({ persons }) => eq(persons.id, `1`))
743 .findOne(),
744 )
745
746 const { result } = renderHook(
747 () => useLiveSuspenseQuery(singlePersonQuery),
748 {
749 wrapper: SuspenseWrapper,
750 },
751 )
752
753 await waitFor(() => {
754 expect(result.current.data).toBeDefined()
755 })
756
757 expect(result.current.data).toMatchObject({
758 id: `1`,
759 name: `John Doe`,
760 age: 30,
761 })
762 })
763
764 it(`should handle StrictMode double-invocation correctly`, async () => {
765 const collection = createCollection(
766 mockSyncCollectionOptions<Person>({
767 id: `test-persons-suspense-strict`,
768 getKey: (person: Person) => person.id,
769 initialData: initialPersons,
770 }),
771 )
772
773 const StrictModeWrapper = ({ children }: { children: ReactNode }) => (
774 <StrictMode>
775 <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
776 </StrictMode>
777 )
778
779 const { result } = renderHook(
780 () => useLiveSuspenseQuery((q) => q.from({ persons: collection })),
781 {
782 wrapper: StrictModeWrapper,
783 },
784 )
785
786 await waitFor(() => {
787 expect(result.current.data).toHaveLength(3)
788 })
789
790 // Verify data is correct despite double-invocation
791 expect(result.current.data).toHaveLength(3)
792 expect(result.current.data[0]).toMatchObject({
793 id: `1`,
794 name: `John Doe`,
795 })
796 })
797
798 it(`should not re-suspend after hasBeenReady when isLoadingSubset changes`, async () => {
799 // This test verifies that after the initial ready state is reached,
800 // subsequent isLoadingSubset changes don't cause re-suspension
801 // (stale-while-revalidate behavior, matching TanStack Query)
802
803 const collection = createCollection(
804 mockSyncCollectionOptions<Person>({
805 id: `test-persons-suspense-on-demand`,
806 getKey: (person: Person) => person.id,
807 initialData: initialPersons,
808 }),
809 )
810
811 let suspenseCount = 0
812
813 const SuspenseTracker = ({ children }: { children: ReactNode }) => {
814 return (
815 <Suspense
816 fallback={
817 <div>
818 {(() => {
819 suspenseCount++
820 return `Loading...`
821 })()}
822 </div>
823 }
824 >
825 {children}
826 </Suspense>
827 )
828 }
829
830 const { result } = renderHook(
831 () => {
832 return useLiveSuspenseQuery((q) => q.from({ persons: collection }))
833 },
834 {
835 wrapper: SuspenseTracker,
836 },
837 )
838
839 // Wait for initial load
840 await waitFor(() => {
841 expect(result.current.data).toHaveLength(3)
842 })
843
844 const initialSuspenseCount = suspenseCount
845
846 // Now simulate on-demand loading by tracking a load promise on the live query collection
847 // This mimics what happens when a new subset query is made in on-demand mode
848 let resolveLoadPromise: () => void
849 const loadPromise = new Promise<void>((resolve) => {
850 resolveLoadPromise = resolve
851 })
852
853 // Track the load promise on the LIVE QUERY collection - this sets isLoadingSubset = true
854 result.current.collection._sync.trackLoadPromise(loadPromise)
855
856 // Verify isLoadingSubset is now true on the live query collection
857 expect(result.current.collection.isLoadingSubset).toBe(true)
858
859 // The collection is still ready, but isLoadingSubset is true
860 expect(result.current.collection.status).toBe(`ready`)
861
862 // Resolve the load promise to simulate data loading complete
863 resolveLoadPromise!()
864
865 // Wait for the loadingSubset:change event to propagate
866 await waitFor(() => {
867 expect(result.current.collection.isLoadingSubset).toBe(false)
868 })
869
870 // After hasBeenReadyRef is set, subsequent isLoadingSubset changes
871 // should NOT cause re-suspension (stale-while-revalidate behavior)
872 expect(suspenseCount).toBe(initialSuspenseCount)
873
874 // Data should still be available
875 expect(result.current.data).toHaveLength(3)
876 })
877})