one
Version:
One is a new React Framework that makes Vite serve both native and web.
390 lines (389 loc) • 13.8 kB
JavaScript
import { describe, expect, it, vi, beforeEach } from "vitest";
import { createHandleRequest } from "./createHandleRequest.native.js";
function _instanceof(left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return !!right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
}
vi.mock("./vite/getManifest", function () {
return {
getManifest: function () {
return {
pageRoutes: [{
file: "app/index.tsx",
page: "/",
namedRegex: "^/(?:/)?$",
routeKeys: {},
type: "ssr",
middlewares: []
}, {
file: "app/(public)/otp+ssg.tsx",
page: "/otp",
namedRegex: "^/otp(?:/)?$",
routeKeys: {},
type: "ssg",
middlewares: [],
hasLoader: false
}, {
file: "app/(public)/profile+ssg.tsx",
page: "/profile",
namedRegex: "^/profile(?:/)?$",
routeKeys: {},
type: "ssg",
middlewares: [],
hasLoader: true
}, {
file: "app/[slug].tsx",
page: "/[slug]",
namedRegex: "^/(?<nxtPslug>[^/]+?)(?:/)?$",
routeKeys: {
nxtPslug: "slug"
},
type: "ssr",
middlewares: []
}, {
file: "app/+not-found.tsx",
page: "/+not-found",
namedRegex: "^/(?<nxtPnotfound>.+?)(?:/)?$",
routeKeys: {
nxtPnotfound: "not-found"
},
type: "spa",
middlewares: []
}],
apiRoutes: [{
file: "app/api/github/agent/run.sh+api.ts",
page: "/api/github/agent/run.sh",
namedRegex: "^/api/github/agent/run\\.sh(?:/)?$",
routeKeys: {},
type: "api",
middlewares: []
}]
};
}
};
});
function createRequest(path) {
var method = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "GET";
return new Request(`http://localhost:3000${path}`, {
method,
headers: {
host: "localhost:3000"
}
});
}
describe("createHandleRequest", function () {
var mockHandlers = {
handlePage: vi.fn().mockResolvedValue("<html></html>")
};
beforeEach(function () {
vi.clearAllMocks();
});
describe("static file extension filtering", function () {
it("should skip paths with file extensions (favicon.ico)", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/favicon.ico"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip paths with file extensions (logo.png)", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/logo.png"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip paths with file extensions (styles.css)", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/styles.css"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip paths with file extensions (robots.txt)", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/robots.txt"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip nested paths with file extensions", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/assets/images/logo.png"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip extensions 2-4 chars like .xyz", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/somefile.xyz"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should skip common static extensions longer than 4 chars", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/font.woff2"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should not render a user +not-found page for sourcemap requests", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/deps-web/react-BwkDMLyL.js.map"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
it("should still route static-looking API paths", async function () {
var mockHandlersWithAPI = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleAPI: vi.fn().mockResolvedValue({
GET: function () {
return new Response("script");
}
})
};
var {
handler
} = createHandleRequest(mockHandlersWithAPI, {
routerRoot: "/app"
});
var result = await handler(createRequest("/api/github/agent/run.sh"));
expect(result).not.toBeNull();
expect(await result.text()).toBe("script");
expect(mockHandlersWithAPI.handleAPI).toHaveBeenCalled();
expect(mockHandlersWithAPI.handlePage).not.toHaveBeenCalled();
});
it("should not skip non-static extensions in route names", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
await handler(createRequest("/route.normal"));
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
it("should NOT skip loader paths ending with _vxrn_loader.js", async function () {
var mockHandlersWithLoader = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleLoader: vi.fn().mockResolvedValue("loader data")
};
var {
handler
} = createHandleRequest(mockHandlersWithLoader, {
routerRoot: "/app"
});
await handler(createRequest("/assets/my-page_123_vxrn_loader.js"));
expect(mockHandlersWithLoader.handleLoader).toHaveBeenCalled();
});
});
describe("loader dispatch short-circuit for no-loader routes", function () {
it("should return empty loader module without calling handleLoader when route has hasLoader: false", async function () {
var mockHandlersWithLoader = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleLoader: vi.fn().mockResolvedValue("loader data")
};
var {
handler
} = createHandleRequest(mockHandlersWithLoader, {
routerRoot: "/app"
});
var response = await handler(createRequest("/assets/otp_123_vxrn_loader.js"));
expect(mockHandlersWithLoader.handleLoader).not.toHaveBeenCalled();
expect(response).not.toBeNull();
expect(response.status).toBe(200);
expect(response.headers.get("Content-Type")).toBe("text/javascript");
var body = await response.text();
expect(body).toContain("export function loader()");
expect(body).toContain("return undefined");
});
it("should still call handleLoader when route has hasLoader: true", async function () {
var mockHandlersWithLoader = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleLoader: vi.fn().mockResolvedValue("export function loader(){return 1}")
};
var {
handler
} = createHandleRequest(mockHandlersWithLoader, {
routerRoot: "/app"
});
await handler(createRequest("/assets/profile_123_vxrn_loader.js"));
expect(mockHandlersWithLoader.handleLoader).toHaveBeenCalled();
});
it("should still call handleLoader when hasLoader is undefined (dev/back-compat)", async function () {
var mockHandlersWithLoader = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleLoader: vi.fn().mockResolvedValue("loader data")
};
var {
handler
} = createHandleRequest(mockHandlersWithLoader, {
routerRoot: "/app"
});
await handler(createRequest("/assets/my-page_123_vxrn_loader.js"));
expect(mockHandlersWithLoader.handleLoader).toHaveBeenCalled();
});
});
describe("dynamic route matching", function () {
it("should match dynamic routes for regular paths without extensions", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
await handler(createRequest("/my-page"));
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
it("should match index route", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
await handler(createRequest("/"));
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
it("should match paths with hyphens", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
await handler(createRequest("/my-awesome-page"));
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
});
describe("request method dispatch", function () {
it("answers HEAD page requests exactly like GET", async function () {
var handlePage = vi.fn(async function () {
return new Response("<html></html>", {
headers: {
"content-type": "text/html"
}
});
});
var {
handler
} = createHandleRequest({
handlePage
}, {
routerRoot: "/app"
});
var get = await handler(createRequest("/my-page", "GET"));
var head = await handler(createRequest("/my-page", "HEAD"));
if (!_instanceof(get, Response) || !_instanceof(head, Response)) {
throw new Error("expected both GET and HEAD to return a Response");
}
expect(head.status).toBe(get.status);
expect(head.headers.get("content-type")).toBe(get.headers.get("content-type"));
expect(handlePage).toHaveBeenCalledTimes(2);
});
it("continues routing HEAD requests to API handlers", async function () {
var mockHandlersWithAPI = {
handlePage: vi.fn().mockResolvedValue("<html></html>"),
handleAPI: vi.fn().mockResolvedValue({
HEAD: function () {
return new Response(null, {
status: 204
});
}
})
};
var {
handler
} = createHandleRequest(mockHandlersWithAPI, {
routerRoot: "/app"
});
var result = await handler(createRequest("/api/github/agent/run.sh", "HEAD"));
expect(result).toBeInstanceOf(Response);
if (!_instanceof(result, Response)) {
throw new Error("expected HEAD API request to return a Response");
}
expect(result.status).toBe(204);
expect(mockHandlersWithAPI.handleAPI).toHaveBeenCalledOnce();
expect(mockHandlersWithAPI.handlePage).not.toHaveBeenCalled();
});
it("does not route POST requests to page handlers", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/my-page", "POST"));
expect(result).toBeNull();
expect(mockHandlers.handlePage).not.toHaveBeenCalled();
});
});
describe("special paths", function () {
it("should skip __vxrnhmr path", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var result = await handler(createRequest("/__vxrnhmr"));
expect(result).toBeNull();
});
it("should skip vite internal paths like /@fs/", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
expect(await handler(createRequest("/@fs/some/path"))).toBeNull();
expect(await handler(createRequest("/@vite/client"))).toBeNull();
expect(await handler(createRequest("/@id/__x00__virtual:one-entry"))).toBeNull();
});
it("should NOT skip user routes that start with @", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
await handler(createRequest("/@admin"));
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
});
describe("requests without a Host header", function () {
it("resolves an absolute request URL with no Host header", async function () {
var {
handler
} = createHandleRequest(mockHandlers, {
routerRoot: "/app"
});
var request = new Request("http://localhost:3000/some-page");
expect(request.headers.get("host")).toBeNull();
await expect(handler(request)).resolves.not.toThrow();
expect(mockHandlers.handlePage).toHaveBeenCalled();
});
});
});
//# sourceMappingURL=createHandleRequest.test.native.js.map