More tests and cleanup

Author: brophdawg11

packages/react-router/__tests__/router/router-test.ts

@@ -936,6 +936,42 @@ describe("a router", () => {
       });
     });
 
+    it("does not run middlewares when complete hydrationData exists", async () => {
+      let middlewareSpy = jest.fn();
+      let loaderSpy = jest.fn();
+      let router = createRouter({
+        history: createMemoryHistory(),
+        routes: [
+          {
+            id: "index",
+            path: "/",
+            middleware: [middlewareSpy],
+            loader: loaderSpy,
+          },
+        ],
+        hydrationData: {
+          loaderData: {
+            index: "INDEX DATA",
+          },
+        },
+      });
+      router.initialize();
+
+      expect(router.state).toMatchObject({
+        historyAction: "POP",
+        location: {
+          pathname: "/",
+        },
+        initialized: true,
+        navigation: IDLE_NAVIGATION,
+        loaderData: {
+          index: "INDEX DATA",
+        },
+      });
+      expect(middlewareSpy).not.toHaveBeenCalled();
+      expect(loaderSpy).not.toHaveBeenCalled();
+    });
+
     it("kicks off initial data load if no hydration data is provided", async () => {
       let parentDfd = createDeferred();
       let parentSpy = jest.fn(() => parentDfd.promise);
@@ -993,6 +1029,61 @@ describe("a router", () => {
       router.dispose();
     });
 
+    it("run middlewares without loaders on initial load if no hydration data is provided", async () => {
+      let parentDfd = createDeferred();
+      let parentSpy = jest.fn(() => parentDfd.promise);
+      let childDfd = createDeferred();
+      let childSpy = jest.fn(() => childDfd.promise);
+      let router = createRouter({
+        history: createMemoryHistory(),
+        routes: [
+          {
+            path: "/",
+            middleware: [parentSpy],
+            children: [
+              {
+                index: true,
+                middleware: [childSpy],
+              },
+            ],
+          },
+        ],
+      });
+      router.initialize();
+      await tick();
+
+      expect(console.warn).not.toHaveBeenCalled();
+      expect(parentSpy.mock.calls.length).toBe(1);
+      expect(childSpy.mock.calls.length).toBe(0);
+      expect(router.state).toMatchObject({
+        historyAction: "POP",
+        location: expect.objectContaining({ pathname: "/" }),
+        initialized: false,
+        navigation: IDLE_NAVIGATION,
+      });
+      expect(router.state.loaderData).toEqual({});
+
+      await parentDfd.resolve(undefined);
+      expect(router.state).toMatchObject({
+        historyAction: "POP",
+        location: expect.objectContaining({ pathname: "/" }),
+        initialized: false,
+        navigation: IDLE_NAVIGATION,
+      });
+      expect(router.state.loaderData).toEqual({});
+
+      await childDfd.resolve(undefined);
+      expect(router.state).toMatchObject({
+        historyAction: "POP",
+        location: expect.objectContaining({ pathname: "/" }),
+        initialized: true,
+        navigation: IDLE_NAVIGATION,
+        loaderData: {},
+      });
+
+      router.dispose();
+    });
+
     it("allows routes to be initialized with undefined loaderData", async () => {
       let t = setup({
         routes: [

packages/react-router/lib/router/router.ts

@@ -960,11 +960,7 @@ export function createRouter(init: RouterInit): Router {
       // functions around still then we'll need to run them in initialize()
       initialized = false;
     } else if (
-      !initialMatches.some(
-        (m) =>
-          m.route.loader ||
-          (m.route.middleware && m.route.middleware.length > 0),
-      )
+      !initialMatches.some((m) => routeHasLoaderOrMiddleware(m.route))
     ) {
       // If we've got no loaders or middleware to run, then we're good to go
       initialized = true;
@@ -2098,7 +2094,9 @@ export function createRouter(init: RouterInit): Router {
     if (
       !init.dataStrategy &&
       !dsMatches.some((m) => m.shouldLoad) &&
-      !dsMatches.some((m) => m.route.middleware) &&
+      !dsMatches.some(
+        (m) => m.route.middleware && m.route.middleware.length > 0,
+      ) &&
       revalidatingFetchers.length === 0
     ) {
       let updatedFetchers = markFetchRedirectsDone();
@@ -4769,7 +4767,7 @@ function getMatchesToLoad(
     } else if (route.lazy) {
       // We haven't loaded this route yet so we don't know if it's got a loader!
       forceShouldLoad = true;
-    } else if (route.loader == null) {
+    } else if (!routeHasLoaderOrMiddleware(route)) {
       // Nothing to load!
       forceShouldLoad = false;
     } else if (initialHydration) {
@@ -4956,6 +4954,13 @@ function getMatchesToLoad(
   return { dsMatches, revalidatingFetchers };
 }
 
+function routeHasLoaderOrMiddleware(route: RouteObject) {
+  return (
+    route.loader != null ||
+    (route.middleware != null && route.middleware.length > 0)
+  );
+}
+
 function shouldLoadRouteOnHydration(
   route: AgnosticDataRouteObject,
   loaderData: RouteData | null | undefined,
@@ -4967,7 +4972,7 @@ function shouldLoadRouteOnHydration(
   }
 
   // No loader or middleware, nothing to run
-  if (!route.loader && (!route.middleware || route.middleware.length === 0)) {
+  if (!routeHasLoaderOrMiddleware(route)) {
     return false;
   }