Open History to see the last commit
1import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library'
2
3import { afterEach, describe, expect, test, vi } from 'vitest'
4
5import { z } from 'zod'
6import {
7 Link,
8 Outlet,
9 RouterProvider,
10 createMemoryHistory,
11 createRootRoute,
12 createRoute,
13 createRouter,
14 useRouter,
15} from '../src'
16
17import { sleep } from './utils'
18
19afterEach(() => {
20 cleanup()
21 vi.useRealTimers()
22 vi.resetAllMocks()
23 window.history.replaceState(null, 'root', '/')
24})
25
26const WAIT_TIME = 100
27
28describe('loaders are being called', () => {
29 test('called on /', async () => {
30 const indexLoaderMock = vi.fn()
31
32 const rootRoute = createRootRoute({})
33 const indexRoute = createRoute({
34 getParentRoute: () => rootRoute,
35 path: '/',
36 loader: async () => {
37 await sleep(WAIT_TIME)
38 indexLoaderMock('foo')
39 },
40 component: () => <div>Index page</div>,
41 })
42 const routeTree = rootRoute.addChildren([indexRoute])
43 const router = createRouter({ routeTree })
44
45 render(() => <RouterProvider router={router} />)
46
47 const indexElement = await screen.findByText('Index page')
48 expect(indexElement).toBeInTheDocument()
49
50 expect(router.state.location.href).toBe('/')
51 expect(window.location.pathname).toBe('/')
52
53 expect(indexLoaderMock).toHaveBeenCalled()
54 })
55
56 test('both are called on /nested/foo', async () => {
57 const nestedLoaderMock = vi.fn()
58 const nestedFooLoaderMock = vi.fn()
59
60 const rootRoute = createRootRoute({})
61 const indexRoute = createRoute({
62 getParentRoute: () => rootRoute,
63 path: '/',
64 component: () => {
65 return (
66 <div>
67 <h1>Index page</h1>
68 <Link to="/nested/foo">link to foo</Link>
69 </div>
70 )
71 },
72 })
73 const nestedRoute = createRoute({
74 getParentRoute: () => rootRoute,
75 path: '/nested',
76 loader: async () => {
77 await sleep(WAIT_TIME)
78 nestedLoaderMock('nested')
79 },
80 })
81 const fooRoute = createRoute({
82 getParentRoute: () => nestedRoute,
83 path: '/foo',
84 loader: async () => {
85 await sleep(WAIT_TIME)
86 nestedFooLoaderMock('foo')
87 },
88 component: () => <div>Nested Foo page</div>,
89 })
90 const routeTree = rootRoute.addChildren([
91 nestedRoute.addChildren([fooRoute]),
92 indexRoute,
93 ])
94 const router = createRouter({ routeTree })
95
96 render(() => <RouterProvider router={router} />)
97
98 const linkToAbout = await screen.findByText('link to foo')
99 fireEvent.click(linkToAbout)
100
101 const fooElement = await screen.findByText('Nested Foo page')
102 expect(fooElement).toBeInTheDocument()
103
104 expect(router.state.location.href).toBe('/nested/foo')
105 expect(window.location.pathname).toBe('/nested/foo')
106
107 expect(nestedLoaderMock).toHaveBeenCalled()
108 expect(nestedFooLoaderMock).toHaveBeenCalled()
109 })
110})
111
112describe('loaders parentMatchPromise', () => {
113 test('parentMatchPromise is defined in a child route', async () => {
114 const nestedLoaderMock = vi.fn()
115
116 const rootRoute = createRootRoute({})
117 const indexRoute = createRoute({
118 getParentRoute: () => rootRoute,
119 path: '/',
120 component: () => (
121 <div>
122 Index page
123 <Link to="/nested/foo">link to foo</Link>
124 </div>
125 ),
126 })
127 const nestedRoute = createRoute({
128 getParentRoute: () => rootRoute,
129 path: '/nested',
130 loader: async () => {
131 await sleep(WAIT_TIME)
132 return 'nested'
133 },
134 component: () => <Outlet />,
135 })
136 const fooRoute = createRoute({
137 getParentRoute: () => nestedRoute,
138 path: '/foo',
139 loader: async ({ parentMatchPromise }) => {
140 nestedLoaderMock(parentMatchPromise)
141 const parentMatch = await parentMatchPromise
142 expect(parentMatch.loaderData).toBe('nested')
143 },
144 component: () => <div>Nested Foo page</div>,
145 })
146 const routeTree = rootRoute.addChildren([
147 nestedRoute.addChildren([fooRoute]),
148 indexRoute,
149 ])
150 const router = createRouter({ routeTree })
151
152 render(() => <RouterProvider router={router} />)
153
154 const linkToFoo = await screen.findByRole('link', { name: 'link to foo' })
155
156 expect(linkToFoo).toBeInTheDocument()
157
158 fireEvent.click(linkToFoo)
159
160 const fooElement = await screen.findByText('Nested Foo page')
161 expect(fooElement).toBeInTheDocument()
162
163 expect(nestedLoaderMock).toHaveBeenCalled()
164 expect(nestedLoaderMock.mock.calls[0]?.[0]).toBeInstanceOf(Promise)
165 })
166})
167
168test('reproducer for #2031', async () => {
169 const rootRoute = createRootRoute({
170 beforeLoad: () => {
171 console.log('beforeload called')
172 },
173 })
174
175 const searchSchema = z.object({
176 data: z.string().array().default([]),
177 })
178
179 const indexRoute = createRoute({
180 getParentRoute: () => rootRoute,
181 path: '/',
182 component: () => <div>Index page</div>,
183
184 validateSearch: searchSchema,
185 })
186
187 const routeTree = rootRoute.addChildren([indexRoute])
188 const router = createRouter({ routeTree })
189
190 render(() => <RouterProvider router={router} />)
191
192 const indexElement = await screen.findByText('Index page')
193 expect(indexElement).toBeInTheDocument()
194})
195
196test('reproducer for #2053', async () => {
197 const rootRoute = createRootRoute({
198 beforeLoad: () => {
199 console.log('beforeload called')
200 },
201 })
202
203 const fooRoute = createRoute({
204 getParentRoute: () => rootRoute,
205 path: '/foo/$fooId',
206 component: () => {
207 const params = fooRoute.useParams()
208 return <div>fooId: {params().fooId}</div>
209 },
210 })
211
212 window.history.replaceState(null, 'root', '/foo/3ΚΑΠΠΑ')
213
214 const routeTree = rootRoute.addChildren([fooRoute])
215
216 const router = createRouter({
217 routeTree,
218 })
219
220 render(() => <RouterProvider router={router} />)
221
222 const fooElement = await screen.findByText('fooId: 3ΚΑΠΠΑ')
223 expect(fooElement).toBeInTheDocument()
224})
225
226test('reproducer for #2198 - throw error from beforeLoad upon initial load', async () => {
227 const rootRoute = createRootRoute({})
228
229 const indexRoute = createRoute({
230 getParentRoute: () => rootRoute,
231 path: '/',
232 component: () => <div>Index page</div>,
233 beforeLoad: () => {
234 throw new Error('Test!')
235 },
236 errorComponent: () => <div>indexErrorComponent</div>,
237 })
238
239 const routeTree = rootRoute.addChildren([indexRoute])
240 const router = createRouter({
241 routeTree,
242 defaultErrorComponent: () => {
243 return <div>defaultErrorComponent</div>
244 },
245 })
246
247 render(() => <RouterProvider router={router} />)
248
249 const errorElement = await screen.findByText('indexErrorComponent')
250 expect(errorElement).toBeInTheDocument()
251})
252
253test('throw error from loader upon initial load', async () => {
254 const rootRoute = createRootRoute({})
255
256 const indexRoute = createRoute({
257 getParentRoute: () => rootRoute,
258 path: '/',
259 component: () => <div>Index page</div>,
260 loader: () => {
261 throw new Error('Test!')
262 },
263 errorComponent: () => <div>indexErrorComponent</div>,
264 })
265
266 const routeTree = rootRoute.addChildren([indexRoute])
267 const router = createRouter({
268 routeTree,
269 defaultErrorComponent: () => {
270 return <div>defaultErrorComponent</div>
271 },
272 })
273
274 render(() => <RouterProvider router={router} />)
275
276 const errorElement = await screen.findByText('indexErrorComponent')
277 expect(errorElement).toBeInTheDocument()
278})
279
280test('throw error from beforeLoad when navigating to route', async () => {
281 const rootRoute = createRootRoute({})
282
283 const indexRoute = createRoute({
284 getParentRoute: () => rootRoute,
285 path: '/',
286 component: () => (
287 <div>
288 <h1>Index page</h1> <Link to="/foo">link to foo</Link>
289 </div>
290 ),
291 errorComponent: () => <div>indexErrorComponent</div>,
292 })
293
294 const fooRoute = createRoute({
295 getParentRoute: () => rootRoute,
296 path: '/foo',
297 component: () => <div>Foo page</div>,
298 beforeLoad: () => {
299 throw new Error('Test!')
300 },
301 errorComponent: () => <div>fooErrorComponent</div>,
302 })
303
304 const routeTree = rootRoute.addChildren([indexRoute, fooRoute])
305 const router = createRouter({
306 routeTree,
307 defaultErrorComponent: () => {
308 return <div>defaultErrorComponent</div>
309 },
310 })
311
312 render(() => <RouterProvider router={router} />)
313
314 const linkToFoo = await screen.findByRole('link', { name: 'link to foo' })
315
316 expect(linkToFoo).toBeInTheDocument()
317
318 fireEvent.click(linkToFoo)
319
320 const indexElement = await screen.findByText('fooErrorComponent')
321 expect(indexElement).toBeInTheDocument()
322})
323
324// https://github.com/TanStack/router/pull/7673
325test('#7673: a spontaneous loader AbortError renders the boundary without executing the route component', async () => {
326 window.history.replaceState(null, 'root', '/app')
327 const rootRoute = createRootRoute({})
328 const abortError = new DOMException('Aborted', 'AbortError')
329 const routeComponentRendered = vi.fn()
330 const renderedError = vi.fn()
331 let routeSignal: AbortSignal | undefined
332
333 const indexRoute = createRoute({
334 getParentRoute: () => rootRoute,
335 path: '/',
336 loader: async ({ abortController }): Promise<{ value: string }> => {
337 routeSignal = abortController.signal
338 return Promise.reject(abortError)
339 },
340 component: () => {
341 routeComponentRendered()
342 const data = indexRoute.useLoaderData()
343 return <div data-testid="index-content">{data().value}</div>
344 },
345 errorComponent: ({ error }) => {
346 renderedError(error)
347 return <div data-testid="index-error">indexErrorComponent</div>
348 },
349 })
350
351 const routeTree = rootRoute.addChildren([indexRoute])
352 const router = createRouter({ routeTree, basepath: '/app' })
353 const rendered = new Promise<void>((resolve) => {
354 const unsubscribe = router.subscribe('onRendered', () => {
355 unsubscribe()
356 resolve()
357 })
358 })
359
360 render(() => <RouterProvider router={router} />)
361
362 expect(await screen.findByTestId('index-error')).toBeInTheDocument()
363 await rendered
364 expect(screen.queryByTestId('index-content')).not.toBeInTheDocument()
365 expect(routeComponentRendered).not.toHaveBeenCalled()
366 // jsdom creates DOMException in another realm, so Solid wraps the error.
367 expect(renderedError).toHaveBeenCalledWith(
368 expect.objectContaining({
369 message: 'Unknown error',
370 cause: abortError,
371 }),
372 )
373 expect(routeSignal?.aborted).toBe(false)
374 expect(
375 router.state.matches.find((match) => match.routeId === indexRoute.id),
376 ).toMatchObject({
377 status: 'error',
378 error: abortError,
379 })
380 expect(window.location.pathname).toBe('/app')
381 expect(router.state.status).toBe('idle')
382})
383
384test('reproducer #4245', async () => {
385 const LOADER_WAIT_TIME = 500
386 const rootRoute = createRootRoute({})
387
388 const indexRoute = createRoute({
389 getParentRoute: () => rootRoute,
390 path: '/',
391 loader: async () => {
392 await sleep(LOADER_WAIT_TIME)
393 return 'index'
394 },
395
396 component: () => {
397 const data = indexRoute.useLoaderData()
398 return (
399 <div>
400 <Link to="/foo" data-testid="link-to-foo">
401 foo
402 </Link>
403 {data()}
404 </div>
405 )
406 },
407 })
408
409 const fooRoute = createRoute({
410 getParentRoute: () => rootRoute,
411 path: '/foo',
412 component: () => (
413 <Link to="/" data-testid="link-to-index">
414 index
415 </Link>
416 ),
417 })
418
419 const routeTree = rootRoute.addChildren([indexRoute, fooRoute])
420 const router = createRouter({ routeTree })
421
422 render(() => <RouterProvider router={router} />)
423 // We wait for the initial loader to complete
424 await router.load()
425 const fooLink = await screen.findByTestId('link-to-foo')
426
427 expect(fooLink).toBeInTheDocument()
428
429 // We navigate to the foo route
430 fireEvent.click(fooLink)
431
432 // We immediately see the content of the foo route
433 const indexLink = await screen.findByTestId('link-to-index', undefined, {
434 timeout: WAIT_TIME,
435 })
436 expect(indexLink).toBeInTheDocument()
437
438 // We navigate to the index route
439 fireEvent.click(indexLink)
440
441 // We immediately see the content of the index route because the stale data is still available
442 const fooLink2 = await screen.findByTestId('link-to-foo', undefined, {
443 timeout: WAIT_TIME,
444 })
445 expect(fooLink2).toBeInTheDocument()
446
447 // We navigate to the foo route again
448 fireEvent.click(fooLink2)
449
450 // We immediately see the content of the foo route
451 const indexLink2 = await screen.findByTestId('link-to-index', undefined, {
452 timeout: WAIT_TIME,
453 })
454 expect(indexLink2).toBeInTheDocument()
455
456 // We navigate to the index route again
457 fireEvent.click(indexLink2)
458
459 // We now should see the content of the index route immediately because the stale data is still available
460 const fooLink3 = await screen.findByTestId('link-to-foo', undefined, {
461 timeout: WAIT_TIME,
462 })
463 expect(fooLink3).toBeInTheDocument()
464})
465
466test('reproducer #4546', async () => {
467 const rootRoute = createRootRoute({
468 component: () => {
469 return (
470 <>
471 <div class="p-2 flex gap-2 text-lg">
472 <Link
473 data-testid="link-to-index"
474 to="/"
475 activeProps={{
476 class: 'font-bold',
477 }}
478 activeOptions={{ exact: true }}
479 >
480 Home
481 </Link>{' '}
482 <Link
483 data-testid="link-to-id"
484 to="$id"
485 params={{
486 id: '1',
487 }}
488 activeProps={{
489 class: 'font-bold',
490 }}
491 >
492 /1
493 </Link>
494 </div>
495 <hr />
496 <Outlet />
497 </>
498 )
499 },
500 })
501
502 let counter = 0
503 const appRoute = createRoute({
504 getParentRoute: () => rootRoute,
505 id: '_app',
506 beforeLoad: () => {
507 counter += 1
508 return {
509 counter,
510 }
511 },
512 component: () => {
513 return (
514 <div>
515 <Header />
516 <Outlet />
517 </div>
518 )
519 },
520 })
521
522 function Header() {
523 const router = useRouter()
524 const ctx = appRoute.useRouteContext()
525
526 return (
527 <div>
528 Header Counter: <p data-testid="header-counter">{ctx().counter}</p>
529 <button
530 onClick={() => {
531 router.invalidate()
532 }}
533 data-testid="invalidate-router"
534 style={{
535 border: '1px solid blue',
536 }}
537 >
538 Invalidate router
539 </button>
540 </div>
541 )
542 }
543
544 const indexRoute = createRoute({
545 getParentRoute: () => appRoute,
546 path: '/',
547 loader: ({ context }) => {
548 return {
549 counter: context.counter,
550 }
551 },
552
553 component: () => {
554 const data = indexRoute.useLoaderData()
555 const ctx = indexRoute.useRouteContext()
556
557 return (
558 <div
559 style={{
560 display: 'flex',
561 'flex-direction': 'column',
562 }}
563 >
564 <div>Index route</div>
565 <div>
566 route context:{' '}
567 <p data-testid="index-route-context">{ctx().counter}</p>
568 </div>
569 <div>
570 loader data: <p data-testid="index-loader-data">{data().counter}</p>
571 </div>
572 </div>
573 )
574 },
575 })
576 const idRoute = createRoute({
577 getParentRoute: () => appRoute,
578 path: '$id',
579 loader: ({ context }) => {
580 return {
581 counter: context.counter,
582 }
583 },
584
585 component: () => {
586 const data = idRoute.useLoaderData()
587 const ctx = idRoute.useRouteContext()
588
589 return (
590 <div
591 style={{
592 display: 'flex',
593 'flex-direction': 'column',
594 }}
595 >
596 <div>$id route</div>
597 <div>
598 route context: <p data-testid="id-route-context">{ctx().counter}</p>
599 </div>
600 <div>
601 loader data: <p data-testid="id-loader-data">{data().counter}</p>
602 </div>
603 </div>
604 )
605 },
606 })
607
608 const routeTree = rootRoute.addChildren([
609 appRoute.addChildren([indexRoute, idRoute]),
610 ])
611 const router = createRouter({ routeTree })
612
613 render(() => <RouterProvider router={router} />)
614
615 const indexLink = await screen.findByTestId('link-to-index')
616 expect(indexLink).toBeInTheDocument()
617
618 const idLink = await screen.findByTestId('link-to-id')
619 expect(idLink).toBeInTheDocument()
620
621 const invalidateRouterButton = await screen.findByTestId('invalidate-router')
622 expect(invalidateRouterButton).toBeInTheDocument()
623
624 {
625 const headerCounter = await screen.findByTestId('header-counter')
626 expect(headerCounter).toHaveTextContent('1')
627
628 const routeContext = await screen.findByTestId('index-route-context')
629 expect(routeContext).toHaveTextContent('1')
630
631 const loaderData = await screen.findByTestId('index-loader-data')
632 expect(loaderData).toHaveTextContent('1')
633 }
634
635 fireEvent.click(idLink)
636
637 {
638 // Wait for navigation to complete before checking values
639 await screen.findByText('$id route')
640 const headerCounter = await screen.findByTestId('header-counter')
641 expect(headerCounter).toHaveTextContent('2')
642
643 const routeContext = await screen.findByTestId('id-route-context')
644 expect(routeContext).toHaveTextContent('2')
645
646 const loaderData = await screen.findByTestId('id-loader-data')
647 expect(loaderData).toHaveTextContent('2')
648 }
649
650 fireEvent.click(indexLink)
651
652 {
653 // beforeLoad is fresh for this navigation, while the cached loader data is
654 // allowed to remain visible until its background reload completes.
655 await screen.findByText('Index route')
656 const headerCounter = await screen.findByTestId('header-counter')
657 expect(headerCounter).toHaveTextContent('3')
658
659 const routeContext = await screen.findByTestId('index-route-context')
660 expect(routeContext).toHaveTextContent('3')
661
662 const loaderData = await screen.findByTestId('index-loader-data')
663 await vi.waitFor(() => expect(loaderData).toHaveTextContent('3'))
664 }
665
666 fireEvent.click(invalidateRouterButton)
667
668 {
669 // Wait for router to invalidate and reload
670 await new Promise((resolve) => setTimeout(resolve, 50))
671 const headerCounter = await screen.findByTestId('header-counter')
672 expect(headerCounter).toHaveTextContent('4')
673
674 const routeContext = await screen.findByTestId('index-route-context')
675 expect(routeContext).toHaveTextContent('4')
676
677 const loaderData = await screen.findByTestId('index-loader-data')
678 expect(loaderData).toHaveTextContent('4')
679 }
680
681 fireEvent.click(idLink)
682
683 {
684 // This loader generation can likewise begin with reusable cached data.
685 await screen.findByText('$id route')
686 const headerCounter = await screen.findByTestId('header-counter')
687 expect(headerCounter).toHaveTextContent('5')
688
689 const routeContext = await screen.findByTestId('id-route-context')
690 expect(routeContext).toHaveTextContent('5')
691
692 const loaderData = await screen.findByTestId('id-loader-data')
693 await vi.waitFor(() => expect(loaderData).toHaveTextContent('5'))
694 }
695})
696
697test('does not show pending UI when loaders finish before their pending delays', async () => {
698 const defaultPendingComponentOnMountMock = vi.fn()
699 const nestedPendingComponentOnMountMock = vi.fn()
700 const fooPendingComponentOnMountMock = vi.fn()
701
702 function getPendingComponent(onMount: () => void) {
703 const PendingComponent = () => {
704 onMount()
705 return <div>Pending...</div>
706 }
707 return PendingComponent
708 }
709
710 const history = createMemoryHistory({ initialEntries: ['/'] })
711
712 const rootRoute = createRootRoute({})
713 const indexRoute = createRoute({
714 getParentRoute: () => rootRoute,
715 path: '/',
716 component: () => {
717 return (
718 <div>
719 <h1>Index page</h1>
720 <Link data-testid="link-to-foo" to="/nested/foo">
721 link to foo
722 </Link>
723 </div>
724 )
725 },
726 })
727 const nestedRoute = createRoute({
728 getParentRoute: () => rootRoute,
729 path: '/nested',
730 // this route does not specify pendingMinMs, so it will use the defaultPendingMs from the router
731 // which is set to WAIT_TIME * 2
732 // since the loader immediately resolves, the pending component must NOT be shown
733 pendingComponent: getPendingComponent(nestedPendingComponentOnMountMock),
734 loader: () => {
735 return 'nested'
736 },
737 })
738 const fooRoute = createRoute({
739 getParentRoute: () => nestedRoute,
740 path: '/foo',
741 // this route's loader takes WAIT_TIME * 5, so it will take longer than the defaultPendingMs
742 // however, this route specifies pendingMs as WAIT_TIME * 10,
743 // so this route's pending component must also NOT be shown
744 pendingComponent: getPendingComponent(fooPendingComponentOnMountMock),
745 pendingMs: WAIT_TIME * 10,
746 loader: async () => {
747 await sleep(WAIT_TIME * 5)
748 },
749 component: () => <div>Nested Foo page</div>,
750 })
751 const routeTree = rootRoute.addChildren([
752 nestedRoute.addChildren([fooRoute]),
753 indexRoute,
754 ])
755 const router = createRouter({
756 routeTree,
757 history,
758 defaultPendingMs: WAIT_TIME * 2,
759 defaultPendingComponent: getPendingComponent(
760 defaultPendingComponentOnMountMock,
761 ),
762 })
763
764 render(() => <RouterProvider router={router} />)
765 await screen.findByTestId('link-to-foo')
766 vi.useFakeTimers()
767 const navigation = router.navigate({ to: '/nested/foo' })
768 await vi.advanceTimersByTimeAsync(WAIT_TIME * 5)
769 await navigation
770 const fooElement = screen.getByText('Nested Foo page')
771 expect(fooElement).toBeInTheDocument()
772
773 expect(router.state.location.href).toBe('/nested/foo')
774 expect(router.state.status).toBe('idle')
775
776 // none of the pending components should have been called
777 expect(defaultPendingComponentOnMountMock).not.toHaveBeenCalled()
778 expect(nestedPendingComponentOnMountMock).not.toHaveBeenCalled()
779 expect(fooPendingComponentOnMountMock).not.toHaveBeenCalled()
780})
781
782test('navigating away from a pending route aborts its loader', async () => {
783 function getPendingComponent(onMount: () => void) {
784 const PendingComponent = () => {
785 onMount()
786 return <div>Pending...</div>
787 }
788 return PendingComponent
789 }
790 const onAbortMock = vi.fn()
791 const fooPendingComponentOnMountMock = vi.fn()
792 let fooSignal: AbortSignal | undefined
793 const history = createMemoryHistory({ initialEntries: ['/'] })
794 const rootRoute = createRootRoute({
795 component: () => (
796 <div>
797 <h1>Index page</h1>
798 <Link data-testid="link-to-foo" to="/foo">
799 link to foo
800 </Link>
801 <Link data-testid="link-to-bar" to="/bar">
802 link to bar
803 </Link>
804 <Outlet />
805 </div>
806 ),
807 })
808 const fooRoute = createRoute({
809 getParentRoute: () => rootRoute,
810 path: '/foo',
811 pendingMs: 0,
812 loader: async ({ abortController }) => {
813 fooSignal = abortController.signal
814 await new Promise<void>((resolve) => {
815 abortController.signal.addEventListener(
816 'abort',
817 () => {
818 onAbortMock()
819 resolve()
820 },
821 { once: true },
822 )
823 })
824 },
825 pendingComponent: getPendingComponent(fooPendingComponentOnMountMock),
826 component: () => <div>Foo page</div>,
827 })
828 const barRoute = createRoute({
829 getParentRoute: () => rootRoute,
830 path: '/bar',
831 component: () => <div>Bar page</div>,
832 })
833 const routeTree = rootRoute.addChildren([fooRoute, barRoute])
834 const router = createRouter({ routeTree, history })
835 render(() => <RouterProvider router={router} />)
836 const fooLink = await screen.findByTestId('link-to-foo')
837 fireEvent.click(fooLink)
838 const pendingElement = await screen.findByText('Pending...')
839 expect(pendingElement).toBeInTheDocument()
840 expect(fooSignal?.aborted).toBe(false)
841 await router.navigate({ to: '/bar' })
842 const barElement = screen.getByText('Bar page')
843 expect(barElement).toBeInTheDocument()
844
845 expect(fooPendingComponentOnMountMock).toHaveBeenCalled()
846 expect(onAbortMock).toHaveBeenCalledTimes(1)
847 expect(fooSignal?.aborted).toBe(true)
848 expect(screen.queryByText('Pending...')).not.toBeInTheDocument()
849 expect(screen.queryByText('Foo page')).not.toBeInTheDocument()
850 expect(router.state.location.href).toBe('/bar')
851 expect(router.state.status).toBe('idle')
852})