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

callbacks.test.ts

281 lines9.0 KB

1import { describe, expect, it, test, vi } from 'vitest'
2import { createMemoryHistory } from '@tanstack/history'
3import { BaseRootRoute, BaseRoute } from '../src'
4import { createTestRouter } from './routerTestUtils'
5​
6describe('callbacks', () => {
7 const setup = ({
8 onEnter,
9 onLeave,
10 onStay,
11 }: {
12 onEnter?: () => void
13 onLeave?: () => void
14 onStay?: () => void
15 }) => {
16 const rootRoute = new BaseRootRoute({})
17​
18 const fooRoute = new BaseRoute({
19 getParentRoute: () => rootRoute,
20 path: '/foo',
21 onLeave,
22 onEnter,
23 onStay,
24 })
25​
26 const barRoute = new BaseRoute({
27 getParentRoute: () => rootRoute,
28 path: '/bar',
29 onLeave,
30 onEnter,
31 onStay,
32 })
33​
34 const routeTree = rootRoute.addChildren([fooRoute, barRoute])
35​
36 const router = createTestRouter({
37 routeTree,
38 history: createMemoryHistory(),
39 })
40​
41 return router
42 }
43​
44 const createFooRouter = (
45 opts: {
46 onEnter?: () => void
47 onLeave?: () => void
48 onStay?: () => void
49 loader?: () => unknown
50 staleTime?: number
51 } = {},
52 ) => {
53 const rootRoute = new BaseRootRoute({})
54 const fooRoute = new BaseRoute({
55 getParentRoute: () => rootRoute,
56 path: '/foo',
57 loaderDeps: ({ search }: { search: Record<string, unknown> }) => ({
58 page: search['page'],
59 }),
60 onEnter: opts.onEnter,
61 onLeave: opts.onLeave,
62 onStay: opts.onStay,
63 loader: opts.loader,
64 staleTime: opts.staleTime,
65 gcTime: opts.staleTime,
66 })
67 return createTestRouter({
68 routeTree: rootRoute.addChildren([fooRoute]),
69 history: createMemoryHistory(),
70 })
71 }
72 describe('onEnter', () => {
73 it('runs on navigate to a new route', async () => {
74 const onEnter = vi.fn()
75 const router = setup({ onEnter })
76​
77 // Entering foo
78 await router.navigate({ to: '/foo' })
79 expect(onEnter).toHaveBeenNthCalledWith(
80 1,
81 expect.objectContaining({ id: '/foo/foo' }),
82 )
83​
84 // Entering bar
85 await router.navigate({ to: '/bar' })
86 expect(onEnter).toHaveBeenNthCalledWith(
87 2,
88 expect.objectContaining({ id: '/bar/bar' }),
89 )
90 })
91 })
92​
93 describe('onLeave', () => {
94 it('runs on navigate from a previous route', async () => {
95 const onLeave = vi.fn()
96 const router = setup({ onLeave })
97 await router.navigate({ to: '/foo' })
98​
99 // Leaving foo to bar
100 await router.navigate({ to: '/bar' })
101 expect(onLeave).toHaveBeenNthCalledWith(
102 1,
103 expect.objectContaining({ id: '/foo/foo' }),
104 )
105​
106 // Leaving bar to foo
107 await router.navigate({ to: '/foo' })
108 expect(onLeave).toHaveBeenNthCalledWith(
109 2,
110 expect.objectContaining({ id: '/bar/bar' }),
111 )
112 })
113 })
114​
115 describe('onStay', () => {
116 it('runs on navigate to the same route', async () => {
117 const onStay = vi.fn()
118 const router = setup({ onStay })
119 await router.navigate({ to: '/foo' })
120​
121 // Staying on foo
122 await router.navigate({ to: '/foo', search: { foo: 'baz' } })
123 expect(onStay).toHaveBeenNthCalledWith(
124 1,
125 expect.objectContaining({ id: '/foo/foo', search: { foo: 'baz' } }),
126 )
127​
128 // Staying on foo
129 await router.navigate({ to: '/foo', search: { foo: 'quux' } })
130 expect(onStay).toHaveBeenNthCalledWith(
131 2,
132 expect.objectContaining({ id: '/foo/foo', search: { foo: 'quux' } }),
133 )
134 })
135​
136 it('runs instead of onLeave/onEnter when loaderDeps change from search param updates', async () => {
137 const onEnter = vi.fn()
138 const onLeave = vi.fn()
139 const onStay = vi.fn()
140 const router = createFooRouter({ onEnter, onLeave, onStay })
141​
142 // Navigate to foo β€” onEnter should fire
143 await router.navigate({ to: '/foo', search: { page: '1' } })
144 expect(onEnter).toHaveBeenCalledTimes(1)
145 expect(onLeave).toHaveBeenCalledTimes(0)
146 expect(onStay).toHaveBeenCalledTimes(0)
147​
148 // Update search param that's in loaderDeps β€” onStay should fire, not onLeave+onEnter
149 await router.navigate({ to: '/foo', search: { page: '2' } })
150 expect(onEnter).toHaveBeenCalledTimes(1) // no new onEnter
151 expect(onLeave).toHaveBeenCalledTimes(0) // no onLeave
152 expect(onStay).toHaveBeenCalledTimes(1) // onStay fires
153​
154 // Update again β€” onStay fires again
155 await router.navigate({ to: '/foo', search: { page: '3' } })
156 expect(onEnter).toHaveBeenCalledTimes(1)
157 expect(onLeave).toHaveBeenCalledTimes(0)
158 expect(onStay).toHaveBeenCalledTimes(2)
159 })
160 })
161​
162 // Regression tests: switching lifecycle hooks to use routeId must NOT break
163 // match-level caching, which still relies on match.id (routeId + params + loaderDeps).
164 describe('same-route match caching', () => {
165 const setupWithPathParams = ({
166 loader,
167 staleTime,
168 }: {
169 loader?: () => unknown
170 staleTime?: number
171 }) => {
172 const rootRoute = new BaseRootRoute({})
173 const postRoute = new BaseRoute({
174 getParentRoute: () => rootRoute,
175 path: '/posts/$postId',
176 loader,
177 staleTime,
178 gcTime: staleTime,
179 })
180 const routeTree = rootRoute.addChildren([postRoute])
181 return createTestRouter({
182 routeTree,
183 history: createMemoryHistory(),
184 })
185 }
186​
187 test('keeps previous loaderDeps variant cached and reuses it within staleTime', async () => {
188 const loader = vi.fn()
189 const router = createFooRouter({ loader, staleTime: 60_000 })
190​
191 await router.navigate({ to: '/foo', search: { page: '1' } })
192 const page1MatchId = router.state.matches.find(
193 (d) => d.routeId === '/foo',
194 )?.id
195 expect(page1MatchId).toBeDefined()
196​
197 await router.navigate({ to: '/foo', search: { page: '2' } })
198 const page2MatchId = router.state.matches.find(
199 (d) => d.routeId === '/foo',
200 )?.id
201 expect(page2MatchId).toBeDefined()
202 expect(page2MatchId).not.toBe(page1MatchId)
203 await router.navigate({ to: '/foo', search: { page: '1' } })
204 expect(loader).toHaveBeenCalledTimes(2)
205 expect(router.state.matches.some((d) => d.id === page1MatchId)).toBe(true)
206 })
207​
208 test('keeps previous params variant cached and reuses it within staleTime', async () => {
209 const loader = vi.fn()
210 const router = setupWithPathParams({ loader, staleTime: 60_000 })
211​
212 await router.navigate({ to: '/posts/$postId', params: { postId: '1' } })
213 const post1MatchId = router.state.matches.find(
214 (d) => d.routeId === '/posts/$postId',
215 )?.id
216 expect(post1MatchId).toBeDefined()
217​
218 await router.navigate({ to: '/posts/$postId', params: { postId: '2' } })
219 const post2MatchId = router.state.matches.find(
220 (d) => d.routeId === '/posts/$postId',
221 )?.id
222 expect(post2MatchId).toBeDefined()
223 expect(post2MatchId).not.toBe(post1MatchId)
224 await router.navigate({ to: '/posts/$postId', params: { postId: '1' } })
225 expect(loader).toHaveBeenCalledTimes(2)
226 expect(router.state.matches.some((d) => d.id === post1MatchId)).toBe(true)
227 })
228 })
229​
230 // Verify that router-level subscription events still fire correctly.
231 // These are used by integrations like Sentry's TanStack Router instrumentation
232 // (https://github.com/getsentry/sentry-javascript/blob/develop/packages/react/src/tanstackrouter.ts)
233 // to track page transitions.
234 describe('onBeforeNavigate event', () => {
235 it('fires when navigating to a new route', async () => {
236 const router = setup({})
237 const onBeforeNavigate = vi.fn()
238 router.subscribe('onBeforeNavigate', onBeforeNavigate)
239​
240 await router.navigate({ to: '/foo' })
241 expect(onBeforeNavigate).toHaveBeenCalledTimes(1)
242 expect(onBeforeNavigate).toHaveBeenCalledWith(
243 expect.objectContaining({
244 type: 'onBeforeNavigate',
245 pathChanged: true,
246 }),
247 )
248 })
249​
250 it('fires on every navigation including same-route loaderDeps changes', async () => {
251 const router = createFooRouter({})
252 const onBeforeNavigate = vi.fn()
253 router.subscribe('onBeforeNavigate', onBeforeNavigate)
254​
255 await router.navigate({ to: '/foo', search: { page: '1' } })
256 expect(onBeforeNavigate).toHaveBeenCalledTimes(1)
257​
258 // loaderDeps change β€” same route, different params
259 await router.navigate({ to: '/foo', search: { page: '2' } })
260 expect(onBeforeNavigate).toHaveBeenCalledTimes(2)
261 })
262​
263 it('includes toLocation and pathChanged in the event', async () => {
264 const router = setup({})
265 const events: Array<{ to: string; pathChanged: boolean }> = []
266 router.subscribe('onBeforeNavigate', (e) => {
267 events.push({
268 to: e.toLocation.pathname,
269 pathChanged: e.pathChanged,
270 })
271 })
272​
273 await router.navigate({ to: '/foo' })
274 await router.navigate({ to: '/bar' })
275​
276 expect(events).toHaveLength(2)
277 expect(events[0]).toMatchObject({ to: '/foo', pathChanged: true })
278 expect(events[1]).toMatchObject({ to: '/bar', pathChanged: true })
279 })
280 })
281})