klaim 1.6.0 → 1.6.2

package/tests/02.route.test.ts

@@ -1,186 +1,186 @@
-import { describe, expect, it } from "vitest";
-import { Api, Klaim, Registry, Route } from "../src/index";
-
-const apiName = "testApi";
-const apiUrl = "https://jsonplaceholder.typicode.com";
-
-await describe("Route", async () => {
-    it("should create an route instance with correct properties", () => {
-        const name = "testRoute";
-        const routePath = "/posts";
-
-        Api.create(apiName, apiUrl, () => {
-            Route.get(name, routePath);
-        });
-
-        expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-    });
-
-    it("should format the path correctly", () => {
-        const name = "testRoute";
-        const routePath = "/posts/";
-        const waitingPath = "posts";
-
-        Api.create(apiName, apiUrl, () => {
-            Route.get(name, routePath);
-        });
-
-        expect(Registry.i.getRoute(apiName, name).url).toBe(waitingPath);
-    });
-
-    it("should format the name to camelCase", () => {
-        const name = "test-route";
-        const waitingName = "testRoute";
-
-        Api.create(apiName, apiUrl, () => {
-            Route.get(name, "/posts");
-        });
-
-        expect(Registry.i.getRoute(apiName, waitingName)).toBeDefined();
-    });
-
-    it("should access the route instance from Klaim", () => {
-        const name = "testRoute";
-
-        Api.create(apiName, apiUrl, () => {
-            Route.get(name, "/posts");
-        });
-
-        expect(Klaim[apiName][name]).toBeDefined();
-    });
-
-    it("should set the headers correctly", () => {
-        const name = "testRoute";
-        const routePath = "/posts";
-        const headers = {
-            "Authorization": "Bearer token 123",
-        };
-
-        Api.create(apiName, apiUrl, () => {
-            Route.get(name, routePath, headers);
-        });
-
-        expect(Registry.i.getRoute(apiName, name).headers).toEqual(headers);
-    });
-
-    describe("Methods", () => {
-        it("should create a GET route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.get(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-
-        it("should create a POST route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.post(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-
-        it("should create a PUT route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.put(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-
-        it("should create a DELETE route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.delete(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-
-        it("should create a PATCH route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.patch(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-
-        it("should create a OPTIONS route instance with correct properties", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-
-            Api.create(apiName, apiUrl, () => {
-                Route.options(name, routePath);
-            });
-
-            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
-        });
-    });
-
-    describe("Arguments", () => {
-        it("should set the arguments correctly", () => {
-            const name = "testRoute";
-            const routePath = "/post/[id]";
-            const args = new Set(["id"]);
-
-            Api.create(apiName, apiUrl, () => {
-                Route.get(name, routePath, {});
-            });
-
-            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
-        });
-
-        it("should set the arguments correctly with multiple arguments", () => {
-            const name = "testRoute";
-            const routePath = "/post/[id]/[name]";
-            const args = new Set(["id", "name"]);
-
-            Api.create(apiName, apiUrl, () => {
-                Route.get(name, routePath, {});
-            });
-
-            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
-        });
-    });
-
-    await describe("Middlewares", async () => {
-        it("should set the before middleware correctly", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-            const before = () => {};
-
-            Api.create(apiName, apiUrl, () => {
-                Route.get(name, routePath, {}).before(before);
-            });
-
-            expect(Registry.i.getRoute(apiName, name).callbacks.before)
-                .toEqual(before);
-        });
-        it("should set the after middleware correctly", () => {
-            const name = "testRoute";
-            const routePath = "/posts";
-            const after = () => {};
-
-            Api.create(apiName, apiUrl, () => {
-                Route.get(name, routePath, {}).after(after);
-            });
-
-            expect(Registry.i.getRoute(apiName, name).callbacks.after)
-                .toEqual(after);
-        });
-    });
-});
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Registry, Route } from "../src/index";
+
+const apiName = "testApi";
+const apiUrl = "https://jsonplaceholder.typicode.com";
+
+await describe("Route", async () => {
+    it("should create an route instance with correct properties", () => {
+        const name = "testRoute";
+        const routePath = "/posts";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath);
+        });
+
+        expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+    });
+
+    it("should format the path correctly", () => {
+        const name = "testRoute";
+        const routePath = "/posts/";
+        const waitingPath = "posts";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath);
+        });
+
+        expect(Registry.i.getRoute(apiName, name).url).toBe(waitingPath);
+    });
+
+    it("should format the name to camelCase", () => {
+        const name = "test-route";
+        const waitingName = "testRoute";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, "/posts");
+        });
+
+        expect(Registry.i.getRoute(apiName, waitingName)).toBeDefined();
+    });
+
+    it("should access the route instance from Klaim", () => {
+        const name = "testRoute";
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, "/posts");
+        });
+
+        expect(Klaim[apiName][name]).toBeDefined();
+    });
+
+    it("should set the headers correctly", () => {
+        const name = "testRoute";
+        const routePath = "/posts";
+        const headers = {
+            "Authorization": "Bearer token 123",
+        };
+
+        Api.create(apiName, apiUrl, () => {
+            Route.get(name, routePath, headers);
+        });
+
+        expect(Registry.i.getRoute(apiName, name).headers).toEqual(headers);
+    });
+
+    describe("Methods", () => {
+        it("should create a GET route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a POST route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.post(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a PUT route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.put(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a DELETE route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.delete(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a PATCH route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.patch(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+
+        it("should create a OPTIONS route instance with correct properties", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+
+            Api.create(apiName, apiUrl, () => {
+                Route.options(name, routePath);
+            });
+
+            expect(Registry.i.getRoute(apiName, name)).toBeDefined();
+        });
+    });
+
+    describe("Arguments", () => {
+        it("should set the arguments correctly", () => {
+            const name = "testRoute";
+            const routePath = "/post/[id]";
+            const args = new Set(["id"]);
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {});
+            });
+
+            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
+        });
+
+        it("should set the arguments correctly with multiple arguments", () => {
+            const name = "testRoute";
+            const routePath = "/post/[id]/[name]";
+            const args = new Set(["id", "name"]);
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {});
+            });
+
+            expect(Registry.i.getRoute(apiName, name).arguments).toEqual(args);
+        });
+    });
+
+    await describe("Middlewares", async () => {
+        it("should set the before middleware correctly", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+            const before = () => {};
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {}).before(before);
+            });
+
+            expect(Registry.i.getRoute(apiName, name).callbacks.before)
+                .toEqual(before);
+        });
+        it("should set the after middleware correctly", () => {
+            const name = "testRoute";
+            const routePath = "/posts";
+            const after = () => {};
+
+            Api.create(apiName, apiUrl, () => {
+                Route.get(name, routePath, {}).after(after);
+            });
+
+            expect(Registry.i.getRoute(apiName, name).callbacks.after)
+                .toEqual(after);
+        });
+    });
+});

package/tests/03.hook.test.ts

@@ -1,34 +1,34 @@
-import { describe, expect, it } from "vitest";
-import { Hook } from "../src/index";
-
-await describe("Route", async () => {
-    it("should subscribe to a hook", () => {
-        let a = 1;
-
-        Hook.subscribe("testHook", () => {
-            a++;
-        });
-
-        Hook.run("testHook");
-        expect(a).toBe(2);
-
-        Hook.run("testHook");
-        expect(a).toBe(3);
-    });
-
-    it("should not run a hook if it is not subscribed", () => {
-        const a = 1;
-
-        Hook.run("testHook");
-        expect(a).toBe(1);
-    });
-
-    it("should not subscribe to a hook if no callback is provided", () => {
-        const a = 1;
-        Hook.subscribe("testHook", undefined);
-
-        Hook.run("testHook");
-
-        expect(a).toBe(1);
-    });
-});
+import { describe, expect, it } from "vitest";
+import { Hook } from "../src/index";
+
+await describe("Route", async () => {
+    it("should subscribe to a hook", () => {
+        let a = 1;
+
+        Hook.subscribe("testHook", () => {
+            a++;
+        });
+
+        Hook.run("testHook");
+        expect(a).toBe(2);
+
+        Hook.run("testHook");
+        expect(a).toBe(3);
+    });
+
+    it("should not run a hook if it is not subscribed", () => {
+        const a = 1;
+
+        Hook.run("testHook");
+        expect(a).toBe(1);
+    });
+
+    it("should not subscribe to a hook if no callback is provided", () => {
+        const a = 1;
+        Hook.subscribe("testHook", undefined);
+
+        Hook.run("testHook");
+
+        expect(a).toBe(1);
+    });
+});

package/tests/04.klaim.test.ts

@@ -1,96 +1,96 @@
-import { describe, expect, it } from "vitest";
-import { Api, Klaim, Route } from "../src/index";
-
-const apiName = "testApi";
-const apiUrl = "https://jsonplaceholder.typicode.com";
-
-const routeName = "testRoute";
-const routeUrl = "/todos/1";
-const routeUrlWithArg = "/todos/[id]";
-const res = {
-    userId: 1,
-    id: 1,
-    title: "delectus aut autem",
-    completed: false,
-};
-
-const res2 = {
-    userId: 1,
-    id: 2,
-    title: "quis ut nam facilis et officia qui",
-    completed: false,
-};
-
-await describe("Route", async () => {
-    it("should call the API", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl);
-        });
-
-        expect(Klaim[apiName]).toBeDefined();
-        expect(Klaim[apiName][routeName]).toBeDefined();
-        expect(Klaim[apiName][routeName]).toBeInstanceOf(Function);
-        expect(Klaim[apiName][routeName]()).toBeInstanceOf(Promise);
-        expect(Klaim[apiName][routeName]()).resolves.toEqual(res);
-    });
-
-    it("should have a body if post but not if get", async () => {
-        const apiNameA = `${apiName}A`;
-        const routeNameA = `${routeName}A`;
-
-        const apiNameB = `${apiName}B`;
-        const routeNameB = `${routeName}B`;
-
-        Api.create(apiNameA, apiUrl, () => {
-            Route.get(routeNameA, routeUrl);
-        });
-
-        Api.create(apiNameB, apiUrl, () => {
-            Route.post(routeNameB, routeUrl);
-        });
-
-        expect(Klaim[apiNameA][routeNameA]()).resolves.toEqual(res);
-        expect(Klaim[apiNameB][routeNameB]()).resolves.toEqual({});
-    });
-
-    it("should can have arguments", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrlWithArg);
-        });
-
-        expect(Klaim[apiName][routeName]({ id: 1 })).resolves.toEqual(res);
-        expect(Klaim[apiName][routeName]({ id: 2 })).resolves.toEqual(res2);
-        // if pass no argument, it should fail
-        expect(Klaim[apiName][routeName]()).rejects.toThrow();
-    });
-
-    it("should call the before and after hooks", async () => {
-        let a = 0;
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl)
-                .before(() => {
-                    a = 1;
-                });
-        });
-
-        expect(a).toEqual(0);
-        Klaim[apiName][routeName]();
-        expect(a).toEqual(1);
-    });
-
-    it("should call the after hook", async () => {
-        let a = 0;
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl)
-                .after(() => {
-                    a = 1;
-                });
-        });
-
-        expect(a).toEqual(0);
-        Klaim[apiName][routeName]();
-        expect(a).toEqual(0);
-        await Klaim[apiName][routeName]();
-        expect(a).toEqual(1);
-    });
-});
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Route } from "../src/index";
+
+const apiName = "testApi";
+const apiUrl = "https://jsonplaceholder.typicode.com";
+
+const routeName = "testRoute";
+const routeUrl = "/todos/1";
+const routeUrlWithArg = "/todos/[id]";
+const res = {
+    userId: 1,
+    id: 1,
+    title: "delectus aut autem",
+    completed: false,
+};
+
+const res2 = {
+    userId: 1,
+    id: 2,
+    title: "quis ut nam facilis et officia qui",
+    completed: false,
+};
+
+await describe("Route", async () => {
+    it("should call the API", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl);
+        });
+
+        expect(Klaim[apiName]).toBeDefined();
+        expect(Klaim[apiName][routeName]).toBeDefined();
+        expect(Klaim[apiName][routeName]).toBeInstanceOf(Function);
+        expect(Klaim[apiName][routeName]()).toBeInstanceOf(Promise);
+        expect(Klaim[apiName][routeName]()).resolves.toEqual(res);
+    });
+
+    it("should have a body if post but not if get", async () => {
+        const apiNameA = `${apiName}A`;
+        const routeNameA = `${routeName}A`;
+
+        const apiNameB = `${apiName}B`;
+        const routeNameB = `${routeName}B`;
+
+        Api.create(apiNameA, apiUrl, () => {
+            Route.get(routeNameA, routeUrl);
+        });
+
+        Api.create(apiNameB, apiUrl, () => {
+            Route.post(routeNameB, routeUrl);
+        });
+
+        expect(Klaim[apiNameA][routeNameA]()).resolves.toEqual(res);
+        expect(Klaim[apiNameB][routeNameB]()).resolves.toEqual({});
+    });
+
+    it("should can have arguments", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrlWithArg);
+        });
+
+        expect(Klaim[apiName][routeName]({ id: 1 })).resolves.toEqual(res);
+        expect(Klaim[apiName][routeName]({ id: 2 })).resolves.toEqual(res2);
+        // if pass no argument, it should fail
+        expect(Klaim[apiName][routeName]()).rejects.toThrow();
+    });
+
+    it("should call the before and after hooks", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl)
+                .before(() => {
+                    a = 1;
+                });
+        });
+
+        expect(a).toEqual(0);
+        Klaim[apiName][routeName]();
+        expect(a).toEqual(1);
+    });
+
+    it("should call the after hook", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl)
+                .after(() => {
+                    a = 1;
+                });
+        });
+
+        expect(a).toEqual(0);
+        Klaim[apiName][routeName]();
+        expect(a).toEqual(0);
+        await Klaim[apiName][routeName]();
+        expect(a).toEqual(1);
+    });
+});