@esmx/router 3.0.0-rc.18 → 3.0.0-rc.20

package/dist/route-task.test.mjs

@@ -0,0 +1,673 @@
+import { describe, expect, it } from "vitest";
+import {
+  RouteNavigationAbortedError,
+  RouteTaskCancelledError,
+  RouteTaskExecutionError
+} from "./error.mjs";
+import { parsedOptions } from "./options.mjs";
+import { Route } from "./route.mjs";
+import { RouteTaskController, createRouteTask } from "./route-task.mjs";
+import { RouteType } from "./types.mjs";
+function createRealOptions() {
+  return parsedOptions({
+    base: new URL("http://localhost/"),
+    routes: [
+      { path: "/test", component: "TestComponent" },
+      { path: "/about", component: "AboutComponent" },
+      { path: "/redirected", component: "RedirectedComponent" },
+      { path: "/admin", component: "AdminComponent" },
+      { path: "/login", component: "LoginComponent" },
+      { path: "/home", component: "HomeComponent" }
+    ]
+  });
+}
+function createMockRouter() {
+  const options = createRealOptions();
+  return {
+    parsedOptions: options
+  };
+}
+describe("createRouteTask", () => {
+  it("should return original route when task array is empty", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const tasks = [];
+    const result = await createRouteTask({
+      to,
+      from,
+      tasks,
+      router
+    });
+    expect(result).toBe(to);
+  });
+  it("should execute tasks in sequence", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const executionOrder = [];
+    const firstTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task1");
+      return;
+    };
+    const secondTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task2");
+      return async () => ({ success: true });
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: firstTask
+      },
+      {
+        name: "override",
+        task: secondTask
+      }
+    ];
+    const result = await createRouteTask({
+      to,
+      from,
+      tasks,
+      router
+    });
+    expect(executionOrder).toEqual(["task1", "task2"]);
+    expect(result).toBe(to);
+    expect(to.handle).toBeTypeOf("function");
+  });
+  it("should set handle when task returns a function", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const handleFunction = async (to2, from2, router2) => {
+      return { message: "Route handled successfully" };
+    };
+    const successTask = async (route, fromRoute, router2) => {
+      return handleFunction;
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: successTask
+      }
+    ];
+    const result = await createRouteTask({
+      to,
+      from,
+      tasks,
+      router
+    });
+    expect(result).toBe(to);
+    expect(to.handle).toBeTypeOf("function");
+    expect(to.handle).not.toBeNull();
+  });
+  it("should throw RouteNavigationAbortedError when task returns false", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const blockingTask = async (route, fromRoute, router2) => {
+      const shouldProceed = false;
+      return shouldProceed ? void 0 : false;
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: blockingTask
+      }
+    ];
+    await expect(
+      createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      })
+    ).rejects.toThrow(RouteNavigationAbortedError);
+  });
+  it("should handle redirection when task returns a route location string", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const redirectTask = async (route, fromRoute, router2) => {
+      if (route.path === "/test") {
+        return "/redirected";
+      }
+      return;
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: redirectTask
+      }
+    ];
+    const result = await createRouteTask({
+      to,
+      from,
+      tasks,
+      router
+    });
+    expect(result).toBeInstanceOf(Route);
+    expect(result.path).toBe("/redirected");
+  });
+  it("should throw RouteTaskExecutionError when task throws an error", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const errorTask = async (route, fromRoute, router2) => {
+      throw new Error("Task execution failed");
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: errorTask
+      }
+    ];
+    await expect(
+      createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      })
+    ).rejects.toThrow(RouteTaskExecutionError);
+  });
+  it("should handle non-Error exceptions and convert them to Error instances", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const stringErrorTask = async (route, fromRoute, router2) => {
+      throw "String error message";
+    };
+    const numberErrorTask = async (route, fromRoute, router2) => {
+      throw 404;
+    };
+    const objectErrorTask = async (route, fromRoute, router2) => {
+      throw { code: "CUSTOM_ERROR", message: "Custom error object" };
+    };
+    const stringTasks = [
+      { name: "stringError", task: stringErrorTask }
+    ];
+    try {
+      await createRouteTask({ to, from, tasks: stringTasks, router });
+    } catch (error) {
+      expect(error).toBeInstanceOf(RouteTaskExecutionError);
+      expect(
+        error.originalError
+      ).toBeInstanceOf(Error);
+      expect(
+        error.originalError.message
+      ).toBe("String error message");
+    }
+    const numberTasks = [
+      { name: "numberError", task: numberErrorTask }
+    ];
+    try {
+      await createRouteTask({ to, from, tasks: numberTasks, router });
+    } catch (error) {
+      expect(error).toBeInstanceOf(RouteTaskExecutionError);
+      expect(
+        error.originalError
+      ).toBeInstanceOf(Error);
+      expect(
+        error.originalError.message
+      ).toBe("404");
+    }
+    const objectTasks = [
+      { name: "objectError", task: objectErrorTask }
+    ];
+    try {
+      await createRouteTask({ to, from, tasks: objectTasks, router });
+    } catch (error) {
+      expect(error).toBeInstanceOf(RouteTaskExecutionError);
+      expect(
+        error.originalError
+      ).toBeInstanceOf(Error);
+      expect(
+        error.originalError.message
+      ).toBe("[object Object]");
+    }
+  });
+  it("should not execute subsequent tasks once an error is thrown", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const executionOrder = [];
+    const firstTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task1");
+      throw new Error("Task failed");
+    };
+    const secondTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task2");
+      return;
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: firstTask
+      },
+      {
+        name: "beforeEnter",
+        task: secondTask
+      }
+    ];
+    await expect(
+      createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      })
+    ).rejects.toThrow(RouteTaskExecutionError);
+    expect(executionOrder).toEqual(["task1"]);
+  });
+  it("should handle null from route parameter", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const checkFromRouteTask = async (route, fromRoute, router2) => {
+      expect(fromRoute).toBeNull();
+      return async () => ({ success: true });
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: checkFromRouteTask
+      }
+    ];
+    const result = await createRouteTask({
+      to,
+      from: null,
+      tasks,
+      router
+    });
+    expect(result).toBe(to);
+    expect(to.handle).toBeTypeOf("function");
+  });
+  it("should pass the correct to and from parameters to tasks", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const firstTask = async (route, fromRoute, router2) => {
+      expect(route).toBe(to);
+      expect(fromRoute).toBe(from);
+      return;
+    };
+    const secondTask = async (route, fromRoute, router2) => {
+      expect(route).toBe(to);
+      expect(fromRoute).toBe(from);
+      return false;
+    };
+    const thirdTask = async (route, fromRoute, router2) => {
+      throw new Error("This should not be executed");
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: firstTask
+      },
+      {
+        name: "beforeEnter",
+        task: secondTask
+      },
+      {
+        name: "confirm",
+        task: thirdTask
+      }
+    ];
+    await expect(
+      createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      })
+    ).rejects.toThrow(RouteNavigationAbortedError);
+  });
+  it("should execute all tasks until one returns a result", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const from = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/home"
+    });
+    const executionOrder = [];
+    const firstTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task1");
+      return;
+    };
+    const handleFunction = async (to2, from2, router2) => {
+      return { message: "Route handled" };
+    };
+    const secondTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task2");
+      return handleFunction;
+    };
+    const thirdTask = async (route, fromRoute, router2) => {
+      executionOrder.push("task3");
+      return;
+    };
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: firstTask
+      },
+      {
+        name: "beforeEnter",
+        task: secondTask
+      },
+      {
+        name: "confirm",
+        task: thirdTask
+      }
+    ];
+    const result = await createRouteTask({
+      to,
+      from,
+      tasks,
+      router
+    });
+    expect(result).toBe(to);
+    expect(to.handle).toBeTypeOf("function");
+    expect(to.handle).not.toBe(null);
+    expect(executionOrder).toEqual(["task1", "task2"]);
+  });
+  describe("Task cancellation with RouteTaskController", () => {
+    it("should cancel task when abort is called before task execution", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const controller = new RouteTaskController();
+      const firstTask = async (route, fromRoute, router2) => {
+        throw new Error("This should not be executed");
+      };
+      const secondTask = async (route, fromRoute, router2) => {
+        throw new Error("This should also not be executed");
+      };
+      const tasks = [
+        {
+          name: "beforeEach",
+          task: firstTask
+        },
+        {
+          name: "beforeEnter",
+          task: secondTask
+        }
+      ];
+      controller.abort();
+      await expect(
+        createRouteTask({
+          to,
+          from,
+          tasks,
+          controller,
+          router
+        })
+      ).rejects.toThrow(RouteTaskCancelledError);
+    });
+    it("should cancel task when abort is called after first task execution", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const controller = new RouteTaskController();
+      const firstTask = async (route, fromRoute, router2) => {
+        controller.abort();
+        return;
+      };
+      const secondTask = async (route, fromRoute, router2) => {
+        throw new Error("This should not be executed");
+      };
+      const tasks = [
+        {
+          name: "beforeEach",
+          task: firstTask
+        },
+        {
+          name: "beforeEnter",
+          task: secondTask
+        }
+      ];
+      await expect(
+        createRouteTask({
+          to,
+          from,
+          tasks,
+          controller,
+          router
+        })
+      ).rejects.toThrow(RouteTaskCancelledError);
+    });
+    it("should not throw error on shouldCancel if controller is provided", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const handleTask = async (route, fromRoute, router2) => {
+        return async () => ({ success: true });
+      };
+      const tasks = [
+        {
+          name: "beforeEach",
+          task: handleTask
+        }
+      ];
+      const result = await createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      });
+      expect(result).toBe(to);
+      expect(result == null ? void 0 : result.handle).toBeTypeOf("function");
+    });
+  });
+  describe("Real scenario test", () => {
+    it("should correctly handle RouteTaskOptions type verification", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const tasks = [];
+      const routeTaskOptions = {
+        to,
+        from,
+        tasks,
+        router
+      };
+      const result = await createRouteTask(routeTaskOptions);
+      expect(result).toBe(to);
+    });
+    it("should correctly handle RouteTaskOptions with controller", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const tasks = [];
+      const controller = new RouteTaskController();
+      const routeTaskOptions = {
+        to,
+        from,
+        tasks,
+        router,
+        controller
+      };
+      const result = await createRouteTask(routeTaskOptions);
+      expect(result).toBe(to);
+    });
+    it("should correctly create real task function interface", async () => {
+      const router = createMockRouter();
+      const to = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/test"
+      });
+      const from = new Route({
+        options: router.parsedOptions,
+        toType: RouteType.push,
+        toInput: "/home"
+      });
+      const realTaskFunction = async (route, fromRoute, router2) => {
+        expect(route).toBeInstanceOf(Route);
+        expect(fromRoute).toBeInstanceOf(Route);
+        expect(router2).toBeDefined();
+        return async () => ({ success: true });
+      };
+      const tasks = [
+        {
+          name: "beforeEach",
+          task: realTaskFunction
+        }
+      ];
+      const result = await createRouteTask({
+        to,
+        from,
+        tasks,
+        router
+      });
+      expect(result).toBe(to);
+      expect(to.handle).toBeTypeOf("function");
+    });
+  });
+});
+describe("RouteTaskController", () => {
+  it("should handle task cancellation", async () => {
+    const router = createMockRouter();
+    const to = new Route({
+      options: router.parsedOptions,
+      toType: RouteType.push,
+      toInput: "/test"
+    });
+    const controller = new RouteTaskController();
+    controller.abort();
+    const tasks = [
+      {
+        name: "beforeEach",
+        task: async () => async () => ({ success: true })
+      }
+    ];
+    await expect(
+      createRouteTask({
+        to,
+        from: null,
+        tasks,
+        router,
+        controller
+      })
+    ).rejects.toThrow(RouteTaskCancelledError);
+  });
+});