Fix unit tests

Author: brophdawg11

packages/react-router/__tests__/dom/scroll-restoration-test.tsx

@@ -11,10 +11,10 @@ import {
   ScrollRestoration,
   createBrowserRouter,
 } from "../../index";
-import type { FrameworkContextObject } from "../../lib/dom/ssr/entry";
 import { createMemoryRouter, redirect } from "react-router";
 import { FrameworkContext, Scripts } from "../../lib/dom/ssr/components";
 import "@testing-library/jest-dom/extend-expect";
+import { mockFrameworkContext } from "../utils/framework";
 
 describe(`ScrollRestoration`, () => {
   it("restores the scroll position for a page when re-visited", () => {
@@ -207,23 +207,7 @@ describe(`ScrollRestoration`, () => {
       window.scrollTo = scrollTo;
     });
 
-    let context: FrameworkContextObject = {
-      routeModules: { root: { default: () => null } },
-      manifest: {
-        routes: {
-          root: {
-            hasLoader: false,
-            hasAction: false,
-            hasErrorBoundary: false,
-            id: "root",
-            module: "root.js",
-          },
-        },
-        entry: { imports: [], module: "" },
-        url: "",
-        version: "",
-      },
-    };
+    let context = mockFrameworkContext();
 
     it("should render a <script> tag", () => {
       let router = createMemoryRouter([

packages/react-router/__tests__/dom/ssr/components-test.tsx

@@ -14,6 +14,7 @@ import { FrameworkContext } from "../../../lib/dom/ssr/components";
 import invariant from "../../../lib/dom/ssr/invariant";
 import { ServerRouter } from "../../../lib/dom/ssr/server";
 import "@testing-library/jest-dom/extend-expect";
+import { mockEntryContext, mockFrameworkContext } from "../../utils/framework";
 
 const setIntentEvents = ["focus", "mouseEnter", "touchStart"] as const;
 type PrefetchEventHandlerProps = {
@@ -24,7 +25,7 @@ function itPrefetchesPageLinks<
   Props extends { to: any; prefetch?: any } & PrefetchEventHandlerProps
 >(Component: React.ComponentType<Props>) {
   describe('prefetch="intent"', () => {
-    let context = {
+    let context = mockFrameworkContext({
       routeModules: { idk: { default: () => null } },
       manifest: {
         routes: {
@@ -40,8 +41,7 @@ function itPrefetchesPageLinks<
         url: "",
         version: "",
       },
-      future: {},
-    };
+    });
 
     beforeEach(() => {
       jest.useFakeTimers();
@@ -159,7 +159,7 @@ describe("<ServerRouter>", () => {
       "Expected a context"
     );
 
-    let context = {
+    let context = mockEntryContext({
       manifest: {
         routes: {
           root: {
@@ -197,9 +197,7 @@ describe("<ServerRouter>", () => {
         },
         empty: { default: {} },
       },
-      staticHandlerContext,
-      future: {},
-    };
+    });
 
     jest.spyOn(console, "warn").mockImplementation(() => {});
     jest.spyOn(console, "error");
@@ -218,54 +216,55 @@ describe("<ServerRouter>", () => {
 
 describe("<HydratedRouter>", () => {
   it("handles empty default export objects from the compiler", async () => {
-    window.__reactRouterContext = {
-      url: "/",
-      future: {},
-    };
-    window.__reactRouterRouteModules = {
-      root: {
-        default: () => {
-          return (
-            <>
-              <h1>Root</h1>
-              <Outlet />
-            </>
-          );
+    let context = mockFrameworkContext({
+      manifest: {
+        routes: {
+          root: {
+            hasLoader: false,
+            hasAction: false,
+            hasErrorBoundary: false,
+            id: "root",
+            module: "root.js",
+            path: "/",
+          },
+          empty: {
+            hasLoader: false,
+            hasAction: false,
+            hasErrorBoundary: false,
+            id: "empty",
+            module: "empty.js",
+            index: true,
+            parentId: "root",
+          },
         },
+        entry: { imports: [], module: "" },
+        url: "",
+        version: "",
       },
-      empty: { default: {} },
-    };
-    window.__reactRouterManifest = {
-      routes: {
+      routeModules: {
         root: {
-          hasLoader: false,
-          hasAction: false,
-          hasErrorBoundary: false,
-          id: "root",
-          module: "root.js",
-          path: "/",
-        },
-        empty: {
-          hasLoader: false,
-          hasAction: false,
-          hasErrorBoundary: false,
-          id: "empty",
-          module: "empty.js",
-          index: true,
-          parentId: "root",
+          default: () => {
+            return (
+              <>
+                <h1>Root</h1>
+                <Outlet />
+              </>
+            );
+          },
         },
+        empty: { default: {} },
       },
-      entry: { imports: [], module: "" },
-      url: "",
-      version: "",
-    };
+    });
+    window.__reactRouterContext = context;
+    window.__reactRouterRouteModules = context.routeModules;
+    window.__reactRouterManifest = context.manifest;
     window.__reactRouterContext!.stream = new ReadableStream({
       start(controller) {
         window.__reactRouterContext!.streamController = controller;
       },
     }).pipeThrough(new TextEncoderStream());
     window.__reactRouterContext!.streamController.enqueue(
-      // ts-expect-error
+      // @ts-expect-error
       '[{"1":2,"6":4,"7":4},"loaderData",{"3":4,"5":4},"root",null,"empty","actionData","errors"]\n'
     );
     window.__reactRouterContext!.streamController.close();

packages/react-router/__tests__/server-runtime/data-test.ts

@@ -1,6 +1,6 @@
 import { decodeViaTurboStream } from "../../lib/dom/ssr/single-fetch";
-import type { ServerBuild } from "../../lib/server-runtime/build";
 import { createRequestHandler } from "../../lib/server-runtime/server";
+import { mockServerBuild } from "./utils";
 
 describe("loaders", () => {
   // so that HTML/Fetch requests are the same, and so redirects don't hang on to
@@ -11,20 +11,13 @@ describe("loaders", () => {
     };
 
     let routeId = "routes/random";
-    let build = {
-      routes: {
-        [routeId]: {
-          id: routeId,
-          path: "/random",
-          module: {
-            loader,
-          },
-        },
+    let build = mockServerBuild({
+      [routeId]: {
+        path: "/random",
+        default: {},
+        loader,
       },
-      entry: { module: {} },
-      prerender: [],
-      future: {},
-    } as unknown as ServerBuild;
+    });
 
     let handler = createRequestHandler(build);
 

packages/react-router/__tests__/server-runtime/handle-error-test.ts

@@ -1,33 +1,28 @@
-import type { ServerBuild } from "../../lib/server-runtime/build";
 import { createRequestHandler } from "../../lib/server-runtime/server";
 import { ErrorResponseImpl } from "../../lib/router/utils";
+import { mockServerBuild } from "./utils";
+import type { HandleDocumentRequestFunction } from "../../lib/server-runtime/build";
 
-function getHandler(routeModule = {}, entryServerModule = {}) {
-  let routeId = "root";
+function getHandler(
+  routeModule = {},
+  opts: {
+    handleDocumentRequest?: HandleDocumentRequestFunction;
+  } = {}
+) {
   let handleErrorSpy = jest.fn();
-  let build = {
-    routes: {
-      [routeId]: {
-        id: routeId,
+  let build = mockServerBuild(
+    {
+      root: {
         path: "/",
-        module: {
-          default() {},
-          ...routeModule,
-        },
-      },
-    },
-    entry: {
-      module: {
-        handleError: handleErrorSpy,
-        default() {
-          return new Response("<html><body>Dummy document</body></html>");
-        },
-        ...entryServerModule,
+        default() {},
+        ...routeModule,
       },
     },
-    future: {},
-    prerender: [],
-  } as unknown as ServerBuild;
+    {
+      handleError: handleErrorSpy,
+      handleDocumentRequest: opts.handleDocumentRequest,
+    }
+  );
 
   return {
     handler: createRequestHandler(build),
@@ -76,7 +71,7 @@ describe("handleError", () => {
 
     it("provides render-thrown Error", async () => {
       let { handler, handleErrorSpy } = getHandler(undefined, {
-        default() {
+        handleDocumentRequest() {
           throw new Error("Render error");
         },
       });

packages/react-router/__tests__/server-runtime/handler-test.ts

@@ -1,25 +1,15 @@
 import { createRequestHandler } from "../../lib/server-runtime/server";
+import { mockServerBuild } from "./utils";
 
 describe("createRequestHandler", () => {
   it("retains request headers when stripping body off for loaders", async () => {
-    let handler = createRequestHandler({
-      ssr: true,
-      routes: {
-        root: {
-          id: "routes/test",
-          path: "/test",
-          module: {
-            loader: ({ request }) =>
-              Response.json(request.headers.get("X-Foo")),
-          } as any,
-        },
+    let build = mockServerBuild({
+      root: {
+        path: "/test",
+        loader: ({ request }) => Response.json(request.headers.get("X-Foo")),
       },
-      assets: {} as any,
-      entry: { module: {} as any },
-      // @ts-expect-error
-      future: {},
-      prerender: [],
     });
+    let handler = createRequestHandler(build);
 
     let response = await handler(
       new Request("http://.../test", {