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

createLazyRoute.test.tsx

230 lines7.1 KB

1import { afterEach, describe, expect, it, onTestFinished, vi } from 'vitest'
2import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library'
3import {
4 Link,
5 Outlet,
6 RouterProvider,
7 createBrowserHistory,
8 createControlledPromise,
9 createLazyRoute,
10 createMemoryHistory,
11 createRootRoute,
12 createRoute,
13 createRouter,
14} from '../src'
15import type { RouterHistory } from '../src'
16​
17afterEach(() => {
18 vi.resetAllMocks()
19 cleanup()
20})
21​
22function createTestRouter(initialHistory?: RouterHistory) {
23 const history =
24 initialHistory ?? createMemoryHistory({ initialEntries: ['/'] })
25​
26 const rootRoute = createRootRoute({})
27 const indexRoute = createRoute({
28 getParentRoute: () => rootRoute,
29 path: '/',
30 component: () => (
31 <div>
32 <p>Index Route</p>
33 <Link to="/heavy">Link to heavy</Link>
34 </div>
35 ),
36 })
37​
38 const heavyRoute = createRoute({
39 getParentRoute: () => rootRoute,
40 path: '/heavy',
41 }).lazy(() => import('./lazy/heavy').then((d) => d.default('/heavy')))
42​
43 const routeTree = rootRoute.addChildren([indexRoute, heavyRoute])
44​
45 const router = createRouter({ routeTree, history })
46​
47 return {
48 router,
49 routes: { indexRoute, heavyRoute },
50 }
52​
53describe('preload: matched routes', { timeout: 20000 }, () => {
54 it('should wait for lazy options to be streamed in before ', async () => {
55 const { router } = createTestRouter(
56 createMemoryHistory({ initialEntries: ['/'] }),
57 )
58​
59 await router.load()
60​
61 // Preload the route and navigate to it
62 router.preloadRoute({ to: '/heavy' })
63 await router.navigate({ to: '/heavy' })
64​
65 await router.invalidate()
66​
67 expect(router.state.location.pathname).toBe('/heavy')
68​
69 const lazyRoute = router.routesByPath['/heavy']
70​
71 expect(lazyRoute.options.component).toBeDefined()
72 })
73​
74 it('should render the heavy/lazy component', async () => {
75 const { router } = createTestRouter(createBrowserHistory())
76​
77 render(() => <RouterProvider router={router} />)
78​
79 const linkToHeavy = await screen.findByText('Link to heavy')
80 expect(linkToHeavy).toBeInTheDocument()
81​
82 expect(router.state.location.pathname).toBe('/')
83 expect(window.location.pathname).toBe('/')
84​
85 // click the link to navigate to the heavy route
86 fireEvent.click(linkToHeavy)
87​
88 const heavyElement = await screen.findByText('I am sooo heavy')
89​
90 expect(heavyElement).toBeInTheDocument()
91​
92 expect(router.state.location.pathname).toBe('/heavy')
93 expect(window.location.pathname).toBe('/heavy')
94​
95 const lazyRoute = router.routesByPath['/heavy']
96 expect(lazyRoute.options.component).toBeDefined()
97 })
98})
99​
100// https://github.com/TanStack/router/issues/4467
101it('replaces default pending UI when delayed lazy options provide pending UI', async () => {
102 const loader = createControlledPromise<void>()
103 const componentPreload = createControlledPromise<void>()
104 const pendingComponentPreload = createControlledPromise<void>()
105 const preloadComponent = vi.fn(() => componentPreload)
106 const preloadPendingComponent = vi.fn(() => pendingComponentPreload)
107 const Page = Object.assign(() => <h1>Page</h1>, {
108 preload: preloadComponent,
109 })
110 const Pending = Object.assign(() => <p role="status">Loading lazy page</p>, {
111 preload: preloadPendingComponent,
112 })
113 const lazyPageOptions = createLazyRoute('/page')({
114 pendingComponent: Pending,
115 component: Page,
116 })
117 const lazyOptions = createControlledPromise<typeof lazyPageOptions>()
118 const rootRoute = createRootRoute({ component: Outlet })
119 const indexRoute = createRoute({
120 getParentRoute: () => rootRoute,
121 path: '/',
122 component: () => <h1>Index page</h1>,
123 })
124 const pageRoute = createRoute({
125 getParentRoute: () => rootRoute,
126 path: '/page',
127 loader: () => loader,
128 }).lazy(() => lazyOptions)
129 const router = createRouter({
130 routeTree: rootRoute.addChildren([indexRoute, pageRoute]),
131 history: createMemoryHistory({ initialEntries: ['/'] }),
132 defaultPendingMs: 0,
133 defaultPendingMinMs: 0,
134 defaultPendingComponent: () => <p role="status">Loading default</p>,
135 })
136 render(() => <RouterProvider router={router} />)
137 expect(await screen.findByText('Index page')).toBeInTheDocument()
138​
139 const navigation = router.navigate({ to: '/page' })
140 onTestFinished(async () => {
141 lazyOptions.resolve(lazyPageOptions)
142 pendingComponentPreload.resolve()
143 componentPreload.resolve()
144 loader.resolve()
145 await Promise.allSettled([navigation])
146 })
147​
148 expect(await screen.findByRole('status')).toHaveTextContent('Loading default')
149​
150 lazyOptions.resolve(lazyPageOptions)
151 await vi.waitFor(() => {
152 expect(preloadComponent).toHaveBeenCalledOnce()
153 expect(preloadPendingComponent).toHaveBeenCalledOnce()
154 })
155 expect(screen.getByRole('status')).toHaveTextContent('Loading default')
156 expect(pendingComponentPreload.status).toBe('pending')
157​
158 pendingComponentPreload.resolve()
159 await vi.waitFor(() =>
160 expect(screen.getByRole('status')).toHaveTextContent('Loading lazy page'),
161 )
162 expect(componentPreload.status).toBe('pending')
163 expect(screen.queryByText('Page')).not.toBeInTheDocument()
164​
165 componentPreload.resolve()
166 loader.resolve()
167 await navigation
168​
169 expect(await screen.findByText('Page')).toBeInTheDocument()
170})
171​
172it('renders an eager loader error with a delayed lazy errorComponent', async () => {
173 const loader = createControlledPromise<void>()
174 const loaderErrorHandled = createControlledPromise<void>()
175 const loaderError = new Error('loader failed')
176 const lazyPageOptions = createLazyRoute('/page')({
177 component: () => <h1>Page</h1>,
178 errorComponent: ({ error }) => (
179 <p role="alert">Lazy error: {error.message}</p>
180 ),
181 })
182 const lazyOptions = createControlledPromise<typeof lazyPageOptions>()
183 const rootRoute = createRootRoute({ component: Outlet })
184 const indexRoute = createRoute({
185 getParentRoute: () => rootRoute,
186 path: '/',
187 component: () => <h1>Index page</h1>,
188 })
189 const pageRoute = createRoute({
190 getParentRoute: () => rootRoute,
191 path: '/page',
192 loader: async () => {
193 await loader
194 throw loaderError
195 },
196 onError: () => loaderErrorHandled.resolve(),
197 }).lazy(() => lazyOptions)
198 const router = createRouter({
199 routeTree: rootRoute.addChildren([indexRoute, pageRoute]),
200 history: createMemoryHistory({ initialEntries: ['/'] }),
201 defaultPendingMs: 0,
202 defaultPendingMinMs: 0,
203 defaultPendingComponent: () => <p role="status">Loading default</p>,
204 })
205 let navigation: Promise<void> | undefined
206​
207 try {
208 render(() => <RouterProvider router={router} />)
209 expect(await screen.findByText('Index page')).toBeInTheDocument()
210​
211 navigation = router.navigate({ to: '/page' })
212 expect(await screen.findByText('Loading default')).toBeInTheDocument()
213​
214 loader.resolve()
215 await loaderErrorHandled
216 lazyOptions.resolve(lazyPageOptions)
217 await navigation
218​
219 expect(await screen.findByRole('alert')).toHaveTextContent(
220 'Lazy error: loader failed',
221 )
222 } finally {
223 lazyOptions.resolve(lazyPageOptions)
224 loader.resolve()
225 loaderErrorHandled.resolve()
226 if (navigation) {
227 await Promise.allSettled([navigation])
228 }
229 }
230})