import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library'
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
import { z } from 'zod'
import { createEffect, onMount } from 'solid-js'
import {
Link,
Outlet,
RouterProvider,
createBrowserHistory,
createRootRoute,
createRoute,
createRouter,
redirect,
} from '../src'
import { sleep } from './utils'
import type { RouterHistory } from '../src'
let history: RouterHistory
beforeEach(() => {
history = createBrowserHistory()
expect(window.location.pathname).toBe('/')
})
afterEach(() => {
history.destroy()
window.history.replaceState(null, 'root', '/')
vi.clearAllMocks()
vi.resetAllMocks()
cleanup()
})
const WAIT_TIME = 150
describe('context function', () => {
describe('context is executed', () => {
async function findByText(text: string) {
const element = await screen.findByText(text)
expect(element).toBeInTheDocument()
}
async function clickButton(name: string) {
const button = await screen.findByRole('button', {
name,
})
expect(button).toBeInTheDocument()
fireEvent.click(button)
}
test('when the path params change', async () => {
const mockContextFn = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
navigate({ to: '/detail/$id', params: { id: 1 } })
}
>
detail-1
)
},
})
const detailRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/detail/$id',
params: {
parse: (p) => z.object({ id: z.coerce.number() }).parse(p),
stringify: (p) => ({ id: `${p.id}` }),
},
context: (args) => {
mockContextFn(args.params)
},
component: () => {
const id = detailRoute.useParams({ select: (params) => params.id })
const navigate = detailRoute.useNavigate()
return (
Detail page: {id()}
navigate({
to: '/detail/$id',
params: (p: any) => ({ ...p, id: p.id + 1 }),
})
}
>
next
)
},
})
const routeTree = rootRoute.addChildren([indexRoute, detailRoute])
const router = createRouter({ routeTree, history })
await render(() => )
await findByText('Index page')
expect(mockContextFn).not.toHaveBeenCalled()
await clickButton('detail-1')
await findByText('Detail page: 1')
console.log(mockContextFn.mock.calls)
expect(mockContextFn).toHaveBeenCalledOnce()
expect(mockContextFn).toHaveBeenCalledWith({ id: 1 })
mockContextFn.mockClear()
await clickButton('next')
await findByText('Detail page: 2')
expect(mockContextFn).toHaveBeenCalledOnce()
expect(mockContextFn).toHaveBeenCalledWith({ id: 2 })
mockContextFn.mockClear()
await clickButton('next')
await findByText('Detail page: 3')
expect(mockContextFn).toHaveBeenCalledOnce()
expect(mockContextFn).toHaveBeenCalledWith({ id: 3 })
mockContextFn.mockClear()
})
test('when loader deps change', async () => {
let generation = 0
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
validateSearch: z.object({
foo: z.string().optional(),
bar: z.string().optional(),
}),
path: '/',
loaderDeps: ({ search }) => ({ foo: search.foo }),
context: ({ deps }) => {
return {
generation: ++generation,
deps: JSON.stringify(deps),
}
},
component: () => {
const navigate = indexRoute.useNavigate()
const context = indexRoute.useRouteContext()
return (
Index page
search: {JSON.stringify(indexRoute.useSearch()())}
context: {context().generation}:{context().deps}
{
navigate({ search: (p: any) => ({ ...p, foo: 'foo-1' }) })
}}
>
foo-1
{
navigate({ search: (p: any) => ({ ...p, foo: 'foo-2' }) })
}}
>
foo-2
{
navigate({ search: (p: any) => ({ ...p, bar: 'bar-1' }) })
}}
>
bar-1
{
navigate({ search: (p: any) => ({ ...p, bar: 'bar-2' }) })
}}
>
bar-2
{
navigate({ search: {} })
}}
>
clear
)
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history })
render(() => )
await findByText('Index page')
await findByText(`search: ${JSON.stringify({})}`)
await findByText('context: 1:{}')
await clickButton('foo-1')
await findByText(`search: ${JSON.stringify({ foo: 'foo-1' })}`)
await findByText('context: 2:{"foo":"foo-1"}')
await clickButton('foo-1')
await findByText(`search: ${JSON.stringify({ foo: 'foo-1' })}`)
await findByText('context: 2:{"foo":"foo-1"}')
await clickButton('bar-1')
await findByText(
`search: ${JSON.stringify({ foo: 'foo-1', bar: 'bar-1' })}`,
)
await findByText('context: 2:{"foo":"foo-1"}')
await clickButton('foo-2')
await findByText(
`search: ${JSON.stringify({ foo: 'foo-2', bar: 'bar-1' })}`,
)
await findByText('context: 3:{"foo":"foo-2"}')
await clickButton('bar-2')
await findByText(
`search: ${JSON.stringify({ foo: 'foo-2', bar: 'bar-2' })}`,
)
await findByText('context: 3:{"foo":"foo-2"}')
await clickButton('clear')
await findByText(`search: ${JSON.stringify({})}`)
await findByText('context: 4:{}')
})
})
describe('accessing values in the context function', () => {
test('receives an empty object', async () => {
const mockIndexContextFn = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => {
mockIndexContextFn(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history })
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexContextFn).toHaveBeenCalledWith({})
})
test('receives an empty object - with an empty object when creating the router', async () => {
const mockIndexContextFn = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => {
mockIndexContextFn(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: {} })
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexContextFn).toHaveBeenCalledWith({})
})
test('receives valid values - with values added when creating the router', async () => {
const mockIndexContextFn = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => {
mockIndexContextFn(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'Router' },
})
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexContextFn).toHaveBeenCalledWith({ project: 'Router' })
})
test('receives valid values when updating the values in the parent route to be read in the child route', async () => {
const mockIndexContextFn = vi.fn()
const rootRoute = createRootRoute({
context: () => ({
project: 'Router',
}),
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => {
mockIndexContextFn(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history })
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexContextFn).toHaveBeenCalledWith({ project: 'Router' })
})
})
describe('return values being available in beforeLoad', () => {
test('when returning an empty object in a regular route', async () => {
const mockIndexBeforeLoad = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: () => ({}),
beforeLoad: ({ context }) => {
mockIndexBeforeLoad(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexBeforeLoad).toHaveBeenCalledWith({ project: 'foo' })
expect(mockIndexBeforeLoad).toHaveBeenCalledTimes(1)
})
test('when updating the initial router context value in a regular route', async () => {
const mockIndexBeforeLoad = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => ({ ...context, project: 'Query' }),
beforeLoad: ({ context }) => {
mockIndexBeforeLoad(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mockIndexBeforeLoad).toHaveBeenCalledWith({ project: 'Query' })
expect(mockIndexBeforeLoad).toHaveBeenCalledTimes(1)
})
test('when returning an empty object in the root route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
context: () => ({}),
beforeLoad: ({ context }) => {
mock(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ project: 'foo' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('when updating the initial router context value in the parent route and in the child route', async () => {
const mockRootBeforeLoad = vi.fn()
const mockIndexBeforeLoad = vi.fn()
const rootRoute = createRootRoute({
context: ({ context }) => ({ ...context, project: 'Router' }),
beforeLoad: ({ context }) => {
mockRootBeforeLoad(context)
},
component: () => (
Root page
),
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => ({ ...context, project: 'Query' }),
beforeLoad: ({ context }) => {
mockIndexBeforeLoad(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'bar' },
})
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mockRootBeforeLoad).toHaveBeenCalledWith({ project: 'Router' })
expect(mockRootBeforeLoad).toHaveBeenCalledTimes(1)
expect(mockIndexBeforeLoad).toHaveBeenCalledWith({ project: 'Query' })
expect(mockIndexBeforeLoad).toHaveBeenCalledTimes(1)
})
})
describe('return values being available in loader', () => {
test('when returning an empty object in a regular route', async () => {
const mockIndexLoader = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: () => ({}),
loader: ({ context }) => {
mockIndexLoader(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const rootElement = await screen.findByText('Index page')
expect(rootElement).toBeInTheDocument()
expect(mockIndexLoader).toHaveBeenCalledWith({ project: 'foo' })
expect(mockIndexLoader).toHaveBeenCalledTimes(1)
})
test('when updating the initial router context value in a regular route', async () => {
const mockIndexLoader = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => ({ ...context, project: 'Query' }),
loader: ({ context }) => {
mockIndexLoader(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mockIndexLoader).toHaveBeenCalledWith({ project: 'Query' })
expect(mockIndexLoader).toHaveBeenCalledTimes(1)
})
test('when returning an empty object in the root route', async () => {
const mockRootLoader = vi.fn()
const rootRoute = createRootRoute({
context: () => ({}),
loader: ({ context }) => {
mockRootLoader(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({
routeTree,
history,
context: { project: 'foo' },
})
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mockRootLoader).toHaveBeenCalledWith({ project: 'foo' })
expect(mockRootLoader).toHaveBeenCalledTimes(1)
})
test('when updating the initial router context value in the root route and in the child route', async () => {
const mockRootLoader = vi.fn()
const mockIndexLoader = vi.fn()
const rootRoute = createRootRoute({
context: ({ context }) => ({ ...context, project: 'Router' }),
loader: ({ context }) => {
mockRootLoader(context)
},
component: () => (
Root page
),
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
context: ({ context }) => ({ ...context, project: 'Query' }),
loader: ({ context }) => {
mockIndexLoader(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({
routeTree,
history,
context: { project: 'bar' },
})
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mockRootLoader).toHaveBeenCalledWith({ project: 'Router' })
expect(mockRootLoader).toHaveBeenCalledTimes(1)
expect(mockIndexLoader).toHaveBeenCalledWith({ project: 'Query' })
expect(mockIndexLoader).toHaveBeenCalledTimes(1)
})
})
})
describe('beforeLoad in the route definition', () => {
// Present at the root route
test('route context, present in the root route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
beforeLoad: ({ context }) => {
mock(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('route context (sleep), present in the root route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Present at the index route
test('route context, present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: ({ context }) => {
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('route context (sleep), present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context that is updated at the root, is the same in the index route
test('modified route context, present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return {
...context,
foo: 'sean',
}
},
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'sean' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context the context is available after a redirect on first-load
test('on first-load, route context is present in the /about route after a redirect is thrown in the beforeLoad of the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/about')
expect(router.state.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('on first-load, route context is present in the /about route after a redirect is thrown in the loader of the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/about')
expect(router.state.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context the context is available after a redirect on navigate
test('on navigate, route context is present in the /person route after a redirect is thrown in the beforeLoad of the /about route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/person')
expect(router.state.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('on navigate, route context is present in the /person route after a redirect is thrown in the loader of the /about route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/person')
expect(router.state.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by /nested/about, is the same as its parent route /nested on navigate
test('nested destination on navigate, route context in the /nested/about route is correctly inherited from the /nested parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/nested/about' })
}}
>
button to about
)
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const aboutRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/about',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/about')
expect(window.location.pathname).toBe('/nested/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by /nested/person route, is the same as its parent route /nested on navigate after a redirect /about
test('nested destination on navigate, when a redirect is thrown in beforeLoad in /about, the /nested/person route context is correctly inherited from its parent /nested', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('nested destination on navigate, when a redirect is thrown in loader in /about, the /nested/person route context is correctly inherited from parent /nested', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (index route) on first-load
test('_layout on first-load, route context in the index route is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const indexRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([indexRoute]),
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/')
expect(window.location.pathname).toBe('/')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (about route) on navigate
test('_layout on navigate, route context in the /about route is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const aboutRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/about',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/about')
expect(window.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (about route) on after a redirect on navigate
test('_layout on navigate, when a redirect is thrown in beforeLoad in /about, the /person route context is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('_layout on navigate, when a redirect is thrown in loader in /about, the /person route context is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('child route receives updated values after the values were previously returned by the child route and then updated by the parent route', async () => {
const mockIndexBeforeLoadFn = vi.fn()
let counter = 0
const rootRoute = createRootRoute({
beforeLoad: () => {
counter++
return {
counter,
}
},
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: ({ context }) => {
mockIndexBeforeLoadFn(context)
return {
counter: context.counter,
}
},
component: () => {
const context = indexRoute.useRouteContext()
return (
Index page
{context().counter}
)
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history })
render(() => )
const rootElement = await screen.findByTestId('index-page')
expect(rootElement).toBeInTheDocument()
async function check(expectedCounter: number) {
const counterElement = await screen.findByTestId('counter')
expect(counterElement).toHaveTextContent(`${expectedCounter}`)
expect(mockIndexBeforeLoadFn).toHaveBeenCalledWith({
counter: expectedCounter,
})
}
await check(1)
await router.invalidate()
await check(2)
})
})
describe('loader in the route definition', () => {
// Present at the root route
test('route context, present in the root route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
loader: ({ context }) => {
mock(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('route context (sleep), present in the root route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Root page
,
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const rootElement = await screen.findByText('Root page')
expect(rootElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Present at the index route
test('route context, present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: ({ context }) => {
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('route context (sleep), present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context that is updated at the root, is the same in the index route
test('modified route context, present in the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute({
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return {
...context,
foo: 'sean',
}
},
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(mock).toHaveBeenCalledWith({ foo: 'sean' })
expect(mock).toHaveBeenCalledTimes(1)
})
// disabled test due to flakiness
test.skip("on navigate (with preload using router methods), loader isn't invoked with undefined context if beforeLoad is pending when navigation happens", async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
})
const aboutRoute = createRoute({
ssr: false,
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
return { mock }
},
loader: async ({ context }) => {
await sleep(WAIT_TIME)
expect(context.mock).toBe(mock)
context.mock()
},
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({
routeTree,
history,
context: { foo: 'bar' },
})
await router.load()
// Don't await, simulate user clicking before preload is done
router.preloadRoute(aboutRoute)
await router.navigate(aboutRoute)
await router.invalidate()
// Expect only a single call as the one from preload and the one from navigate are deduped
expect(mock).toHaveBeenCalledOnce()
})
test("on navigate (with preload), loader isn't invoked with undefined context if beforeLoad is pending when navigation happens", async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
ssr: false,
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
return { mock }
},
loader: async ({ context }) => {
await sleep(WAIT_TIME)
expect(context.mock).toBe(mock)
context.mock()
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({
routeTree,
history,
defaultPreload: 'intent',
context: { foo: 'bar' },
})
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
// Don't await, simulate user clicking before preload is done
fireEvent.focus(linkToAbout)
fireEvent.click(linkToAbout)
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/about')
// Expect only a single call as the one from preload and the one from navigate are deduped
expect(mock).toHaveBeenCalledOnce()
})
// Check if context the context is available after a redirect on first-load
test('on first-load, route context is present in the /about route after a redirect is thrown in beforeLoad of the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/about')
expect(router.state.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('on first-load, route context is present in the /about route after a redirect is thrown in loader of the index route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/about')
expect(router.state.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context the context is available after a redirect on navigate
test('on navigate, route context is present in the /person route after a redirect is thrown in the beforeLoad of the /about route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/person')
expect(router.state.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('on navigate, route context is present in the /person route after a redirect is thrown in the loader of the /about route', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(window.location.pathname).toBe('/person')
expect(router.state.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a /nested/about, is the same as its parent route /nested on navigate
test('nested destination on navigate, route context in the /nested/about route is correctly inherited from the /nested parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/nested/about' })
}}
>
button to about
)
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const aboutRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/about',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/about')
expect(window.location.pathname).toBe('/nested/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a /nested/person route, is the same as its parent route /nested on navigate after a redirect /about
test('nested destination on navigate, when a redirect is thrown in beforeLoad in /about, the /nested/person route context is correctly inherited from its parent /nested', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('nested destination on navigate, when a redirect is thrown in loader in /about, the /nested/person route context is correctly inherited from parent /nested', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'nested' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (index route) on first-load
test('_layout on first-load, route context in the index route is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const indexRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Index page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([indexRoute]),
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const indexElement = await screen.findByText('Index page')
expect(indexElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/')
expect(window.location.pathname).toBe('/')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (about route) on navigate
test('_layout on navigate, route context in the /about route is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const aboutRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/about',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => About page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const aboutElement = await screen.findByText('About page')
expect(aboutElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/about')
expect(window.location.pathname).toBe('/about')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
// Check if context returned by a layout route, is the same its child route (about route) on after a redirect on navigate
test('_layout on navigate, when a redirect is thrown in beforeLoad in /about, the /person route context is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
test('_layout on navigate, when a redirect is thrown in loader in /about, the /person route context is correctly inherited from the layout parent', async () => {
const mock = vi.fn()
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
return (
Index page
{
navigate({ to: '/about' })
}}
>
button to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
loader: async ({ context }) => {
await sleep(WAIT_TIME)
mock(context)
},
component: () => Person page
,
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const buttonToAbout = await screen.findByRole('button', {
name: 'button to about',
})
expect(buttonToAbout).toBeInTheDocument()
fireEvent.click(buttonToAbout)
const personElement = await screen.findByText('Person page')
expect(personElement).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(mock).toHaveBeenCalledWith({ foo: 'bar', layout: 'layout' })
expect(mock).toHaveBeenCalledTimes(1)
})
})
describe('useRouteContext in the component', () => {
// Present at the root route
test('route context, present in the root route', async () => {
const rootRoute = createRootRoute({
component: () => {
const context = rootRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
test('route context (sleep in beforeLoad), present in the root route', async () => {
const rootRoute = createRootRoute({
beforeLoad: async () => {
await sleep(WAIT_TIME)
},
component: () => {
const context = rootRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
// Note: This test passes in solid-router but fails in react-router, even
// though in issue (GitHub #6040), the bug manifests in both routers.
test('route context, (sleep in beforeLoad), with immediate navigation', async () => {
const contextValues: Array<{ data: string }> = []
const rootRoute = createRootRoute({
beforeLoad: async () => {
await sleep(WAIT_TIME)
return { data: 'context-from-beforeLoad' }
},
shellComponent: () => {
const context = rootRoute.useRouteContext()
// Track context value at render time
createEffect(() => {
const contextValue: { data: string } = context()
contextValues.push(contextValue)
})
return
},
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const navigate = indexRoute.useNavigate()
// Navigate away immediately on mount
onMount(() => {
navigate({ to: '/other' })
})
return Index page
},
})
const otherRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/other',
component: () => Other page
,
})
const routeTree = rootRoute.addChildren([indexRoute, otherRoute])
const router = createRouter({ routeTree, history })
render(() => )
// Wait for navigation to complete
await screen.findByText('Other page')
const allContextsValid = contextValues.every(
(c) => c.data === 'context-from-beforeLoad',
)
expect(allContextsValid).toBe(true)
})
test('route context (sleep in loader), present root route', async () => {
const rootRoute = createRootRoute({
loader: async () => {
await sleep(WAIT_TIME)
},
component: () => {
const context = rootRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
// Present at the index route
test('route context, present in the index route', async () => {
const rootRoute = createRootRoute({})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const context = indexRoute.useRouteContext()
if (context === undefined) {
throw new Error('context is undefined')
}
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
test('route context (sleep in beforeLoad), present in the index route', async () => {
const rootRoute = createRootRoute({})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async () => {
await sleep(WAIT_TIME)
},
component: () => {
const context = indexRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
test('route context (sleep in loader), present in the index route', async () => {
const rootRoute = createRootRoute({})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async () => {
await sleep(WAIT_TIME)
},
component: () => {
const context = indexRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
})
// Check if context that is updated at the root, is the same in the root route
test('modified route context, present in the root route', async () => {
const rootRoute = createRootRoute({
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return {
...context,
foo: 'sean',
}
},
component: () => {
const context = rootRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'sean' }))
expect(content).toBeInTheDocument()
})
// Check if the context that is updated at the root, is the same in the index route
test('modified route context, present in the index route', async () => {
const rootRoute = createRootRoute({
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return {
...context,
foo: 'sean',
}
},
})
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
const context = indexRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'sean' }))
expect(content).toBeInTheDocument()
})
// Check if the context that is available after a redirect on first-load
test('on first-load, route context is present in the /about route after a redirect is thrown in the beforeLoad of the index route', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
component: () => {
const context = aboutRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(router.state.location.href).toBe('/about')
expect(window.location.pathname).toBe('/about')
expect(content).toBeInTheDocument()
})
test('on first-load, route context is present in the /about route after a redirect is thrown in the loader of the index route', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/about' })
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
component: () => {
const context = aboutRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([aboutRoute, indexRoute])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(router.state.location.href).toBe('/about')
expect(window.location.pathname).toBe('/about')
expect(content).toBeInTheDocument()
})
// Check if the context that is available after a redirect on navigate
test('on navigate, route context is present in the /person route after a redirect is thrown in the beforeLoad of the /about route', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
})
test('on navigate, route context is present in the /person route after a redirect is thrown in the loader of the /about route', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const personRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
personRoute,
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(JSON.stringify({ foo: 'bar' }))
expect(content).toBeInTheDocument()
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
})
// Check if context returned by /nested/about, is the same its parent /nested on navigate
test('nested destination on navigate, route context in the /nested/about route is correctly inherited from its parent /nested', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
component: () => ,
})
const aboutRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/about',
component: () => {
const context = aboutRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'nested' }),
)
expect(router.state.location.href).toBe('/nested/about')
expect(window.location.pathname).toBe('/nested/about')
expect(content).toBeInTheDocument()
})
// Check if context returned by a layout route, is the same its child route (about route) on after a redirect on navigate
test('nested destination on navigate, when a redirect is thrown in beforeLoad in /about, the /nested/person route context is correctly inherited from its parent /nested', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
component: () => ,
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'nested' }),
)
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(content).toBeInTheDocument()
})
test('nested destination on navigate, when a redirect is thrown in loader in /about, the /nested/person route context is correctly inherited from its parent /nested', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/nested/person' })
},
})
const nestedRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/nested',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'nested' }
},
component: () => ,
})
const personRoute = createRoute({
getParentRoute: () => nestedRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
nestedRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'nested' }),
)
expect(router.state.location.href).toBe('/nested/person')
expect(window.location.pathname).toBe('/nested/person')
expect(content).toBeInTheDocument()
})
// Check if context returned by a layout route, is the same its child route (index route) on first-load
test('_layout on first-load, route context in the index route is correctly inherited from the layout parent', async () => {
const rootRoute = createRootRoute()
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
component: () => ,
})
const indexRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/',
component: () => {
const context = indexRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([indexRoute]),
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'layout' }),
)
expect(router.state.location.href).toBe('/')
expect(window.location.pathname).toBe('/')
expect(content).toBeInTheDocument()
})
// Check if context returned by a layout route, is the same its child route (about route) on navigate
test('_layout on navigate, route context in the /about route is correctly inherited from the layout parent', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
component: () => ,
})
const aboutRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/about',
component: () => {
const context = aboutRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([aboutRoute]),
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'layout' }),
)
expect(router.state.location.href).toBe('/about')
expect(window.location.pathname).toBe('/about')
expect(content).toBeInTheDocument()
})
// Check if context returned by a layout route, is the same its child route (about route) on after a redirect on navigate
test('_layout on navigate, when a redirect is thrown in beforeLoad in /about, the /person route context is correctly inherited from the layout parent', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
beforeLoad: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
component: () => ,
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'layout' }),
)
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(content).toBeInTheDocument()
})
test('_layout on navigate, when a redirect is thrown in loader in /about, the /person route context is correctly inherited from the layout parent', async () => {
const rootRoute = createRootRoute()
const indexRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/',
component: () => {
return (
Index page
link to about
)
},
})
const aboutRoute = createRoute({
getParentRoute: () => rootRoute,
path: '/about',
loader: async () => {
await sleep(WAIT_TIME)
throw redirect({ to: '/person' })
},
})
const layoutRoute = createRoute({
getParentRoute: () => rootRoute,
id: '_layout',
beforeLoad: async ({ context }) => {
await sleep(WAIT_TIME)
return { ...context, layout: 'layout' }
},
component: () => ,
})
const personRoute = createRoute({
getParentRoute: () => layoutRoute,
path: '/person',
component: () => {
const context = personRoute.useRouteContext()
return {JSON.stringify(context())}
},
})
const routeTree = rootRoute.addChildren([
layoutRoute.addChildren([personRoute]),
aboutRoute,
indexRoute,
])
const router = createRouter({ routeTree, history, context: { foo: 'bar' } })
render(() => )
const linkToAbout = await screen.findByRole('link', {
name: 'link to about',
})
expect(linkToAbout).toBeInTheDocument()
fireEvent.click(linkToAbout)
const content = await screen.findByText(
JSON.stringify({ foo: 'bar', layout: 'layout' }),
)
expect(router.state.location.href).toBe('/person')
expect(window.location.pathname).toBe('/person')
expect(content).toBeInTheDocument()
})
})