Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
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
221 changes: 221 additions & 0 deletions integration/navigation-targets-test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,221 @@
import { test, expect } from "@playwright/test";
import {
createFixture,
createAppFixture,
js,
} from "./helpers/create-fixture.js";
import type { AppFixture } from "./helpers/create-fixture.js";
import { PlaywrightFixture } from "./helpers/playwright-fixture.js";

for (let templateName of ["vite-6-template", "rsc-vite-framework"] as const) {
test.describe(`navigation targets: ${templateName}`, () => {
let app: AppFixture;
test.beforeAll(async () => {
let fixture = await createFixture({
templateName,
files: {
"app/routes/_index.tsx": js`
"use client";
import * as React from "react";
import { useFetcher } from "react-router";
export default function Index() {
let fetcher = useFetcher();
let [target, setTarget] = React.useState("/target");
let [error, setError] = React.useState("");
async function run(submit) {
setError("");
try {
if (submit) {
await fetcher.submit({ message: "local form data" }, { method: "post", action: target });
} else {
await fetcher.load(target);
}
} catch (error) {
setError((submit ? "Submit" : "Load") + ": " + error.message);
}
}
return <>
<input aria-label="Target" value={target} onChange={e => setTarget(e.target.value)} />
<button onClick={() => run(false)}>Load</button>
<button onClick={() => run(true)}>Submit</button>
<p id="error">{error}</p>
<pre id="data">{JSON.stringify(fetcher.data)}</pre>
</>;
}
`,
"app/routes/target.tsx": js`
export function loader() { return { value: "local loader" }; }
export async function action({ request }) {
return { value: (await request.formData()).get("message") };
}
export default function Target({ loaderData, actionData }) {
return <h1>{actionData?.value || loaderData?.value}</h1>;
}
`,
"app/routes/paths.tsx": js`
import { Link, Form, href, generatePath } from "react-router";
export default function Paths() {
return <>
<Link id="href" reloadDocument to={href("/:lang?/*", { "*": "/target" })}>href</Link>
<Link id="generate" reloadDocument to={generatePath("/*", { "*": "/target" })}>generatePath</Link>
<Link id="generate-mixed" reloadDocument to={generatePath("/*", { "*": "\\target" })}>Mixed separators</Link>
<Link id="generate-query" reloadDocument to={generatePath("/*", { "*": "target?value=a%20b#top" })}>Query and hash</Link>
<Form reloadDocument method="post" action={href("/:first/:second", { first: "", second: "target" })}>
<input name="message" defaultValue="native form data" />
<button>Native submit</button>
</Form>
</>;
}
`,
"app/routes/native.tsx": js`
import { Link, Form } from "react-router";
export function loader({ request }) {
let url = new URL(request.url);
return { to: url.searchParams.get("to"), kind: url.searchParams.get("kind") };
}
export default function Native({ loaderData }) {
return loaderData.kind === "form"
? <Form reloadDocument action={loaderData.to} method="post"><button>Submit</button></Form>
: <Link reloadDocument to={loaderData.to}>Native link</Link>;
}
`,
"app/routes/redirect.tsx": js`
import { redirect } from "react-router";
export function loader({ request }) {
let url = new URL(request.url);
let to = url.searchParams.get("to");
return url.searchParams.has("raw")
? new Response(null, { status: 302, headers: { Location: to } })
: redirect(to);
}
export default function Redirect() { return <h1>Redirect</h1>; }
`,
},
});
app = await createAppFixture(fixture);
});
test.afterAll(() => app.close());

test("resolves generated link and form paths without JavaScript", async ({
browser,
}) => {
let context = await browser.newContext({ javaScriptEnabled: false });
try {
let page = await context.newPage();
let fixture = new PlaywrightFixture(app, page);
for (let id of [
"href",
"generate",
"generate-mixed",
"generate-query",
]) {
await fixture.goto("/paths");
expect(
await page
.locator(`#${id}`)
.evaluate((a: HTMLAnchorElement) => a.origin),
).toBe(app.serverUrl);
await page.locator(`#${id}`).click();
await expect(page.locator("h1")).toHaveText("local loader");
expect(new URL(page.url()).origin).toBe(app.serverUrl);
if (id === "generate-query") {
expect(new URL(page.url()).search).toBe("?value=a%20b");
expect(new URL(page.url()).hash).toBe("#top");
}
}
await fixture.goto("/paths");
await page.getByRole("button", { name: "Native submit" }).click();
await expect(page.locator("h1")).toHaveText("native form data");
expect(new URL(page.url()).origin).toBe(app.serverUrl);
} finally {
await context.close();
}
});

test("validates native link and form URLs without JavaScript", async ({
browser,
}) => {
let context = await browser.newContext({ javaScriptEnabled: false });
try {
let page = await context.newPage();
let fixture = new PlaywrightFixture(app, page);
for (let [kind, to] of [
["link", "/\\destination.invalid/target"],
["form", "/\t/destination.invalid/target"],
]) {
await fixture.goto("/native?" + new URLSearchParams({ kind, to }));
await expect(page.locator("a, form")).toHaveCount(0);
}
let to = "http://destination.invalid/target";
await page.route(to, (route) =>
route.fulfill({ body: "Explicit external destination" }),
);
await fixture.goto(
"/native?" + new URLSearchParams({ kind: "link", to }),
);
await page.getByRole("link", { name: "Native link" }).click();
await expect(page.locator("body")).toHaveText(
"Explicit external destination",
);
} finally {
await context.close();
}
});

test("validates redirect responses and preserves supported URL formats", async ({
request,
}) => {
for (let raw of [false, true]) {
let query = new URLSearchParams({
to: "/\\destination.invalid/target",
...(raw ? { raw: "1" } : {}),
});
let response = await request.get(app.serverUrl + "/redirect?" + query, {
maxRedirects: 0,
});
expect(response.status()).toBe(500);
expect(response.headers().location).toBeUndefined();
}
let to = "//destination.invalid/target";
let response = await request.get(
app.serverUrl + "/redirect?" + new URLSearchParams({ to }),
{ maxRedirects: 0 },
);
expect(response.status()).toBe(302);
expect(response.headers().location).toBe(to);
});

test("applies fetcher path validation to loads and submissions", async ({
page,
}) => {
let externalRequests: string[] = [];
await page.route("http://destination.invalid/**", (route) => {
externalRequests.push(route.request().url());
return route.fulfill({
headers: { "Access-Control-Allow-Origin": "*" },
body: "External response",
});
});
let fixture = new PlaywrightFixture(app, page);
await fixture.goto("/", true);
await page.getByLabel("Target").fill("/\t/destination.invalid/target");
for (let name of ["Load", "Submit"]) {
await page.getByRole("button", { name, exact: true }).click();
await expect(page.locator("#error")).toHaveText(
name + ": External navigation is not allowed",
);
}
expect(externalRequests).toEqual([]);
await page.getByLabel("Target").fill("/target");
await page.getByRole("button", { name: "Load", exact: true }).click();
await expect(page.locator("#data")).toHaveText(
'{"value":"local loader"}',
);
await page.getByRole("button", { name: "Submit", exact: true }).click();
await expect(page.locator("#data")).toHaveText(
'{"value":"local form data"}',
);
await expect(page.locator("#error")).toBeEmpty();
});
});
}
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
Improve path generation and URL validation across `href()`, `generatePath()`, links, forms, fetchers, and redirects
43 changes: 42 additions & 1 deletion packages/react-router/__tests__/external-navigation-test.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@ const EXPLICIT_EXTERNAL_URLS = [
"//example.com/path",
"mailto:test@example.com",
"tel:5551234567",
"myapp://open/path",
];

const IMPLICIT_EXTERNAL_URLS = [
Expand Down Expand Up @@ -49,6 +50,42 @@ const VALID_INTERNAL_URLS = [
];

describe("external navigation support", () => {
it.each(["\t", "\n", "\r"])(
"validates fetcher load and submission paths containing %j",
async (control) => {
let loader = jest.fn(() => null);
let action = jest.fn(() => null);
let discover = jest.fn();
let router = createRouter({
history: createBrowserHistory(),
routes: [{ id: "root", path: "*", loader, action }],
hydrationData: { loaderData: { root: null } },
patchRoutesOnNavigation: discover,
}).initialize();
try {
for (let opts of [
undefined,
{ formMethod: "post" as const, formData: new FormData() },
]) {
await expect(
router.fetch(
"fetcher",
"root",
`/${control}/example.com/path`,
opts,
),
).rejects.toThrow("External navigation is not allowed");
}
expect(loader).not.toHaveBeenCalled();
expect(action).not.toHaveBeenCalled();
expect(discover).not.toHaveBeenCalled();
expect(router.state.location.pathname).toBe("/");
} finally {
router.dispose();
}
},
);

it.each(EXTERNAL_URLS)(
"router.navigate throws for external navigation to %s",
async (to) => {
Expand Down Expand Up @@ -274,7 +311,11 @@ describe("external navigation support", () => {
{ path: "/" },
{
path: "/start",
loader: () => redirect(location),
loader: () =>
new Response(null, {
status: 302,
headers: { Location: location },
}),
},
],
window: testWindow,
Expand Down
56 changes: 56 additions & 0 deletions packages/react-router/__tests__/generatePath-test.tsx
Original file line number Diff line number Diff line change
@@ -1,6 +1,62 @@
import { generatePath } from "react-router";

describe("generatePath", () => {
it.each([
["/*", "/example.com/a//b", "/example.com/a//b"],
["/:lang?/*", "//example.com/path", "/example.com/path"],
["/*", "\\example.com/path", "/example.com/path"],
["*", "\\/example.com/path", "/example.com/path"],
])("normalizes leading separators for %s", (pattern, splat, expected) => {
let result = generatePath(pattern, { "*": splat });
expect(result).toBe(expected);
expect(new URL(result, "https://app.example/").origin).toBe(
"https://app.example",
);
});

it.each([
["/files/*", "a%20b/%2F", "/files/a%20b/%2F"],
["/files/*", "a?download=1#top", "/files/a?download=1#top"],
["/files/*", "a b/café\\file", "/files/a b/café\\file"],
["/files/*", "a\tb", "/files/a\tb"],
["*", "a?next=https://example.com/#top", "a?next=https://example.com/#top"],
["*", "1:a", "1:a"],
["*", " example/path", " example/path"],
])(
"preserves splat interpolation for %s with %j",
(pattern, splat, expected) => {
expect(generatePath(pattern, { "*": splat })).toBe(expected);
},
);

it.each([
["/*", "/\t/example.com/path"],
["/*", "/\n/example.com/path"],
["/*", "/\r/example.com/path"],
["*", "\u0000//example.com/path"],
["*", " //example.com/path"],
["*", "ht\ttps://example.com/path"],
])("validates generated URL prefixes for %s with %j", (pattern, splat) => {
expect(() => generatePath(pattern, { "*": splat })).toThrow(
"External navigation is not allowed",
);
});

it("encodes colons in the first segment of relative patterns", () => {
for (let result of [
generatePath("*", { "*": "https://example.com/path" }),
generatePath(":protocol/*", {
protocol: "https:",
"*": "/example.com/path",
}),
]) {
expect(result).toBe("https%3A//example.com/path");
expect(new URL(result, "https://app.example/").origin).toBe(
"https://app.example",
);
}
});

describe("with no params", () => {
it("returns the unmodified path", () => {
expect(generatePath("/")).toBe("/");
Expand Down
Loading
Loading