Skip to content

test(router-core): cases for interpolatePath and matchPathname #4024

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
SeanCassiere merged 4 commits into from
Apr 21, 2025
Merged

test(router-core): cases for interpolatePath and matchPathname #4024

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
e7b9854
test(router-core): group the basepath tests for `matchPathname`
SeanCassiere Apr 21, 2025
6e8af24
test(router-core): params matching expectations for `matchPathname`
SeanCassiere Apr 21, 2025
9a44742
test(router-core): correctly group the `interpolatePath` tests
SeanCassiere Apr 21, 2025
f187b6f
test(router-core): add more for `interpolatePath`
SeanCassiere Apr 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
213 changes: 161 additions & 52 deletions packages/router-core/tests/path.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -266,7 +266,7 @@ describe('resolvePath', () => {
})

describe('interpolatePath', () => {
;[
it.each([
{
name: 'should interpolate the path',
path: '/users/$id',
Expand Down Expand Up @@ -324,68 +324,177 @@ describe('interpolatePath', () => {
['@', '+'].map((char) => [encodeURIComponent(char), char]),
),
},
].forEach((exp) => {
it(exp.name, () => {
const result = interpolatePath({
path: exp.path,
params: exp.params,
decodeCharMap: exp.decodeCharMap,
}).interpolatedPath
expect(result).toBe(exp.result)
})
})
})

describe('matchPathname', () => {
it.each([
{
name: 'should match the root path that start with the basepath',
basepath: '/basepath',
pathname: '/basepath',
matchLocation: {
to: '/',
},
expected: {},
name: 'should interpolate the path with the splat param at the end',
path: '/users/$',
params: { _splat: '123' },
result: '/users/123',
},
{
name: 'should match the path that start with the basepath',
basepath: '/basepath',
pathname: '/basepath/abc',
matchLocation: {
to: '/abc',
},
expected: {},
name: 'should interpolate the path with a single named path param and the splat param at the end',
path: '/users/$username/$',
params: { username: 'seancassiere', _splat: '123' },
result: '/users/seancassiere/123',
},
{
name: 'should not match the root path that does not start with the basepath',
basepath: '/basepath',
pathname: '/',
matchLocation: {
to: '/',
},
expected: undefined,
name: 'should interpolate the path with 2 named path params with the splat param at the end',
path: '/users/$username/$id/$',
params: { username: 'seancassiere', id: '123', _splat: '456' },
result: '/users/seancassiere/123/456',
},
{
name: 'should not match the path that does not start with the basepath',
basepath: '/basepath',
pathname: '/abc',
matchLocation: {
to: '/abc',
name: 'should interpolate the path with multiple named path params with the splat param at the end',
path: '/$username/settings/$repo/$id/$',
params: {
username: 'sean-cassiere',
repo: 'my-repo',
id: '123',
_splat: '456',
},
expected: undefined,
result: '/sean-cassiere/settings/my-repo/123/456',
},
{
name: 'should not match the path that match partial of the basepath',
basepath: '/base',
pathname: '/basepath/abc',
matchLocation: {
to: '/abc',
},
expected: undefined,
name: 'should interpolate the path with the splat param containing slashes',
path: '/users/$',
params: { _splat: 'sean/cassiere' },
result: '/users/sean/cassiere',
},
])('$name', ({ basepath, pathname, matchLocation, expected }) => {
expect(matchPathname(basepath, pathname, matchLocation)).toStrictEqual(
expected,
])('$name', ({ path, params, decodeCharMap, result }) => {
expect(
interpolatePath({
path,
params,
decodeCharMap,
}).interpolatedPath,
).toBe(result)
})
})

describe('matchPathname', () => {
describe('basepath matching', () => {
it.each([
{
name: 'should match when the input is the same as the basepath',
basepath: '/basepath',
input: '/basepath',
matchingOptions: {
to: '/',
},
expectedMatchedParams: {},
},
{
name: 'should match when the input starts with the basepath and `to` is set to the remaining',
basepath: '/basepath',
input: '/basepath/abc',
matchingOptions: {
to: '/abc',
},
expectedMatchedParams: {},
},
{
name: 'should not match when the input is `/` and does not start with the basepath',
basepath: '/basepath',
input: '/',
matchingOptions: {
to: '/',
},
expectedMatchedParams: undefined,
},
{
name: 'should not match when the input completely does not start with the basepath',
basepath: '/basepath',
input: '/abc',
matchingOptions: {
to: '/abc',
},
expectedMatchedParams: undefined,
},
{
name: 'should not match when the input only partially matches the basepath',
basepath: '/base',
input: '/basepath/abc',
matchingOptions: {
to: '/abc',
},
expectedMatchedParams: undefined,
},
])(
'$name',
({ basepath, input, matchingOptions, expectedMatchedParams }) => {
expect(matchPathname(basepath, input, matchingOptions)).toStrictEqual(
expectedMatchedParams,
)
},
)
})

describe('path param(s) matching', () => {
it.each([
{
name: 'should not match since `to` does not match the input',
input: '/',
matchingOptions: {
to: '/users',
},
expectedMatchedParams: undefined,
},
{
name: 'should match since `to` matches the input',
input: '/users',
matchingOptions: {
to: '/users',
},
expectedMatchedParams: {},
},
{
name: 'should match and return the named path params',
input: '/users/123',
matchingOptions: {
to: '/users/$id',
},
expectedMatchedParams: { id: '123' },
},
{
name: 'should match and return the the splat param',
input: '/users/123',
matchingOptions: {
to: '/users/$',
},
expectedMatchedParams: {
'*': '123',
_splat: '123',
},
},
{
name: 'should match and return the named path and splat params',
input: '/users/123/456',
matchingOptions: {
to: '/users/$id/$',
},
expectedMatchedParams: {
id: '123',
'*': '456',
_splat: '456',
},
},
{
name: 'should match and return the multiple named path params and splat param',
input: '/sean-cassiere/settings/my-repo/123/456',
matchingOptions: {
to: '/$username/settings/$repo/$id/$',
},
expectedMatchedParams: {
username: 'sean-cassiere',
repo: 'my-repo',
id: '123',
'*': '456',
_splat: '456',
},
},
])('$name', ({ input, matchingOptions, expectedMatchedParams }) => {
expect(matchPathname('/', input, matchingOptions)).toStrictEqual(
expectedMatchedParams,
)
})
})
})
Loading