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

redirect.test.tsx

315 lines8.9 KB

1import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library'
2​
3import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
4import { createControlledPromise } from '@tanstack/router-core'
5​
6import {
7 Link,
8 Outlet,
9 RouterProvider,
10 createBrowserHistory,
11 createRootRoute,
12 createRoute,
13 createRouter,
14 redirect,
15 useRouter,
16} from '../src'
17​
18import { sleep } from './utils'
19import type { RouterHistory } from '../src'
20​
21let history: RouterHistory
22​
23beforeEach(() => {
24 history = createBrowserHistory()
25 expect(window.location.pathname).toBe('/')
26})
27​
28afterEach(() => {
29 history.destroy()
30 vi.clearAllMocks()
31 vi.resetAllMocks()
32 window.history.replaceState(null, 'root', '/')
33 cleanup()
34})
35​
36const WAIT_TIME = 100
37​
38describe('redirect', () => {
39 describe('SPA', () => {
40 test('when `redirect` is thrown in `beforeLoad`', async () => {
41 const nestedLoaderMock = vi.fn()
42 const nestedFooLoaderMock = vi.fn()
43​
44 const rootRoute = createRootRoute({})
45 const indexRoute = createRoute({
46 getParentRoute: () => rootRoute,
47 path: '/',
48 component: () => {
49 return (
50 <div>
51 <h1>Index page</h1>
52 <Link to="/about">link to about</Link>
53 </div>
54 )
55 },
56 })
57 const aboutRoute = createRoute({
58 getParentRoute: () => rootRoute,
59 path: '/about',
60 beforeLoad: async () => {
61 await sleep(WAIT_TIME)
62 throw redirect({ to: '/nested/foo' })
63 },
64 })
65 const nestedRoute = createRoute({
66 getParentRoute: () => rootRoute,
67 path: '/nested',
68 loader: async () => {
69 await sleep(WAIT_TIME)
70 nestedLoaderMock('nested')
71 },
72 })
73 const fooRoute = createRoute({
74 getParentRoute: () => nestedRoute,
75 path: '/foo',
76 loader: async () => {
77 await sleep(WAIT_TIME)
78 nestedFooLoaderMock('foo')
79 },
80 component: () => <div>Nested Foo page</div>,
81 })
82 const routeTree = rootRoute.addChildren([
83 nestedRoute.addChildren([fooRoute]),
84 aboutRoute,
85 indexRoute,
86 ])
87 const router = createRouter({ routeTree })
88​
89 render(() => <RouterProvider router={router} />)
90​
91 const linkToAbout = await screen.findByText('link to about')
92​
93 expect(linkToAbout).toBeInTheDocument()
94​
95 fireEvent.click(linkToAbout)
96​
97 const fooElement = await screen.findByText('Nested Foo page')
98​
99 expect(fooElement).toBeInTheDocument()
100​
101 expect(router.state.location.href).toBe('/nested/foo')
102 expect(window.location.pathname).toBe('/nested/foo')
103​
104 expect(nestedLoaderMock).toHaveBeenCalled()
105 expect(nestedFooLoaderMock).toHaveBeenCalled()
106 })
107​
108 test('when root `beforeLoad` redirects while root pendingComponent is showing and the target route is lazy', async () => {
109 let hasRedirected = false
110 const beforeLoad = createControlledPromise<void>()
111 const consoleError = vi
112 .spyOn(console, 'error')
113 .mockImplementation(() => {})
114​
115 const rootRoute = createRootRoute({
116 component: () => <Outlet />,
117 pendingMs: 0,
118 pendingComponent: () => <div data-testid="pending">loading</div>,
119 beforeLoad: async () => {
120 await beforeLoad
121 if (!hasRedirected) {
122 hasRedirected = true
123 throw redirect({ to: '/posts' })
124 }
125 },
126 })
127​
128 const indexRoute = createRoute({
129 getParentRoute: () => rootRoute,
130 path: '/',
131 component: () => <div data-testid="index-page">Index page</div>,
132 })
133​
134 const postsRoute = createRoute({
135 getParentRoute: () => rootRoute,
136 path: '/posts',
137 }).lazy(() => import('./lazy/normal').then((d) => d.Route('/posts')))
138​
139 const router = createRouter({
140 routeTree: rootRoute.addChildren([indexRoute, postsRoute]),
141 history,
142 })
143​
144 render(() => <RouterProvider router={router} />)
145​
146 try {
147 expect(await screen.findByTestId('pending')).toBeInTheDocument()
148 expect(screen.queryByTestId('index-page')).not.toBeInTheDocument()
149 } finally {
150 beforeLoad.resolve()
151 }
152​
153 // The lazy target route adds the async boundary that exposes the stale
154 // redirected-match render path this regression is guarding.
155 expect(await screen.findByTestId('lazy-route-page')).toBeInTheDocument()
156 expect(screen.queryByTestId('pending')).not.toBeInTheDocument()
157 expect(screen.queryByTestId('index-page')).not.toBeInTheDocument()
158 expect(router.state.location.href).toBe('/posts')
159 await vi.waitFor(() => expect(router.state.status).toBe('idle'))
160 expect(consoleError).not.toHaveBeenCalled()
161 })
162​
163 test('when `redirect` is thrown in `loader`', async () => {
164 const nestedLoaderMock = vi.fn()
165 const nestedFooLoaderMock = vi.fn()
166​
167 const rootRoute = createRootRoute({})
168 const indexRoute = createRoute({
169 getParentRoute: () => rootRoute,
170 path: '/',
171 component: () => {
172 return (
173 <div>
174 <h1>Index page</h1>
175 <Link to="/about">link to about</Link>
176 </div>
177 )
178 },
179 })
180 const aboutRoute = createRoute({
181 getParentRoute: () => rootRoute,
182 path: '/about',
183 loader: async () => {
184 await sleep(WAIT_TIME)
185 throw redirect({
186 to: '/nested/foo',
187 hash: 'some-hash',
188 search: { someSearch: 'hello123' },
189 })
190 },
191 })
192 const nestedRoute = createRoute({
193 getParentRoute: () => rootRoute,
194 path: '/nested',
195 loader: async () => {
196 await sleep(WAIT_TIME)
197 nestedLoaderMock('nested')
198 },
199 })
200 const fooRoute = createRoute({
201 validateSearch: (search) => {
202 return {
203 someSearch: search.someSearch as string,
204 }
205 },
206 getParentRoute: () => nestedRoute,
207 path: '/foo',
208 loader: async () => {
209 await sleep(WAIT_TIME)
210 nestedFooLoaderMock('foo')
211 },
212 component: () => <div>Nested Foo page</div>,
213 })
214 const routeTree = rootRoute.addChildren([
215 nestedRoute.addChildren([fooRoute]),
216 aboutRoute,
217 indexRoute,
218 ])
219 const router = createRouter({ routeTree })
220​
221 render(() => <RouterProvider router={router} />)
222​
223 const linkToAbout = await screen.findByText('link to about')
224​
225 expect(linkToAbout).toBeInTheDocument()
226​
227 fireEvent.click(linkToAbout)
228​
229 const fooElement = await screen.findByText('Nested Foo page')
230​
231 expect(fooElement).toBeInTheDocument()
232​
233 expect(router.state.location.href).toBe(
234 '/nested/foo?someSearch=hello123#some-hash',
235 )
236 expect(window.location.pathname).toBe('/nested/foo')
237​
238 expect(nestedLoaderMock).toHaveBeenCalled()
239 expect(nestedFooLoaderMock).toHaveBeenCalled()
240 })
241​
242 test('when `redirect` is thrown in `loader` after `router.invalidate()`', async () => {
243 let shouldRedirect = false
244​
245 const rootRoute = createRootRoute({})
246 const indexRoute = createRoute({
247 getParentRoute: () => rootRoute,
248 path: '/',
249 component: () => {
250 return (
251 <div>
252 <h1>Index page</h1>
253 <Link data-testid="link-to-about" to="/about">
254 link to about
255 </Link>
256 </div>
257 )
258 },
259 })
260 const aboutRoute = createRoute({
261 getParentRoute: () => rootRoute,
262 path: '/about',
263 loader: async () => {
264 await sleep(WAIT_TIME)
265 if (shouldRedirect) {
266 throw redirect({
267 to: '/final',
268 })
269 }
270 },
271 component: function Component() {
272 const router = useRouter()
273 return (
274 <button
275 data-testid="button-invalidate"
276 onClick={() => {
277 shouldRedirect = true
278 router.invalidate()
279 }}
280 >
281 invalidate
282 </button>
283 )
284 },
285 })
286 const finalRoute = createRoute({
287 getParentRoute: () => rootRoute,
288 path: '/final',
289 component: () => <div>Final</div>,
290 })
291​
292 const routeTree = rootRoute.addChildren([
293 aboutRoute,
294 indexRoute,
295 finalRoute,
296 ])
297 const router = createRouter({ routeTree, history })
298​
299 render(() => <RouterProvider router={router} />)
300​
301 const linkToAbout = await screen.findByTestId('link-to-about')
302 expect(linkToAbout).toBeInTheDocument()
303​
304 fireEvent.click(linkToAbout)
305​
306 const invalidateButton = await screen.findByTestId('button-invalidate')
307 expect(invalidateButton).toBeInTheDocument()
308​
309 fireEvent.click(invalidateButton)
310​
311 expect(await screen.findByText('Final')).toBeInTheDocument()
312 expect(window.location.pathname).toBe('/final')
313 })
314 })
315})