klaim 1.6.0 → 1.6.2

package/tests/05.cache.test.ts

@@ -1,46 +1,46 @@
-import { describe, expect, it } from "vitest";
-import { Api, Klaim, Registry, Route } from "../src/index";
-
-const apiName = "testApi";
-const apiUrl = "https://lorem-json.com/api/";
-
-const routeName = "testRoute";
-const routeUrl = "/json";
-const routeBody = {
-    "name": "{{name()}}",
-};
-
-await describe("Cache", async () => {
-    it("should not cache the API response", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl);
-        });
-
-        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
-        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
-
-        expect(nameA).not.toEqual(nameB);
-    });
-
-    it("should keep the API response in cache", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl);
-        }).withCache();
-
-        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
-        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
-
-        expect(nameA).toEqual(nameB);
-    });
-
-    it("should keep the route response in cache", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl).withCache();
-        });
-
-        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
-        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
-
-        expect(nameA).toEqual(nameB);
-    });
-});
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Registry, Route } from "../src/index";
+
+const apiName = "testApi";
+const apiUrl = "https://lorem-json.com/api/";
+
+const routeName = "testRoute";
+const routeUrl = "/json";
+const routeBody = {
+    "name": "{{name()}}",
+};
+
+await describe("Cache", async () => {
+    it("should not cache the API response", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl);
+        });
+
+        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
+        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
+
+        expect(nameA).not.toEqual(nameB);
+    });
+
+    it("should keep the API response in cache", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl);
+        }).withCache();
+
+        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
+        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
+
+        expect(nameA).toEqual(nameB);
+    });
+
+    it("should keep the route response in cache", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl).withCache();
+        });
+
+        const { name: nameA } = await Klaim[apiName][routeName]({}, routeBody);
+        const { name: nameB } = await Klaim[apiName][routeName]({}, routeBody);
+
+        expect(nameA).toEqual(nameB);
+    });
+});

package/tests/06.retry.test.ts

@@ -1,54 +1,54 @@
-import { describe, expect, it } from "vitest";
-import { Api, Klaim, Route } from "../src/index";
-
-const apiName = "testApi";
-const apiUrl = "https://myfakeapi.jardin-des-slimes.com";
-
-const routeName = "testRoute";
-const routeUrl = "/fake/1";
-
-await describe("Retry", async () => {
-    it("should just fail", async () => {
-        let a = 0;
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl)
-                .onCall(() => a++);
-        });
-
-        expect(Klaim[apiName][routeName]()).rejects.toThrow();
-        expect(a).toEqual(1);
-    });
-
-    it.only("should retry api", async () => {
-        let a = 0;
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl)
-                .onCall(() => a++);
-        })
-            .onCall(() => a--) // Never call route > api
-            .withRetry(3);
-
-        try {
-            await Klaim[apiName][routeName]();
-        } catch (error) {
-            // Dont care
-        }
-        expect(a).toEqual(4);
-    });
-
-    it("should retry route", async () => {
-        let a = 0;
-        Api.create(apiName, apiUrl, () => {
-            Route.post(routeName, routeUrl)
-                .onCall(() => a++)
-                .withRetry(3);
-        });
-
-        try {
-            await Klaim[apiName][routeName]();
-        } catch (error) {
-            // Dont care
-        }
-        expect(a).toEqual(4);
-    });
-});
+import { describe, expect, it } from "vitest";
+import { Api, Klaim, Route } from "../src/index";
+
+const apiName = "testApi";
+const apiUrl = "https://myfakeapi.jardin-des-slimes.com";
+
+const routeName = "testRoute";
+const routeUrl = "/fake/1";
+
+await describe("Retry", async () => {
+    it("should just fail", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl)
+                .onCall(() => a++);
+        });
+
+        expect(Klaim[apiName][routeName]()).rejects.toThrow();
+        expect(a).toEqual(1);
+    });
+
+    it.only("should retry api", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl)
+                .onCall(() => a++);
+        })
+            .onCall(() => a--) // Never call route > api
+            .withRetry(3);
+
+        try {
+            await Klaim[apiName][routeName]();
+        } catch (error) {
+            // Dont care
+        }
+        expect(a).toEqual(4);
+    });
+
+    it("should retry route", async () => {
+        let a = 0;
+        Api.create(apiName, apiUrl, () => {
+            Route.post(routeName, routeUrl)
+                .onCall(() => a++)
+                .withRetry(3);
+        });
+
+        try {
+            await Klaim[apiName][routeName]();
+        } catch (error) {
+            // Dont care
+        }
+        expect(a).toEqual(4);
+    });
+});

package/tests/07.validate.test.ts

@@ -1,61 +1,61 @@
-import {describe, it} from "vitest";
-import {Api, Klaim, Route} from "../src/index";
-import * as yup from "yup";
-
-const apiName = "testApi";
-const apiUrl = "https://jsonplaceholder.typicode.com";
-
-const routeName = "testRoute";
-const routeUrl = "todos/[id]";
-
-const schema = yup.object().shape({
-    userId: yup.number().required(),
-    id: yup.number().min(1).max(10).required(),
-    title: yup.string().required(),
-    completed: yup.boolean().required()
-});
-
-describe("Validate Yup", async () => {
-    it("should not fail", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl);
-        });
-
-        // Expect the validation to not fail the promise
-        expect(await Klaim[apiName][routeName]({id: 1})).toStrictEqual({
-            userId: 1,
-            id: 1,
-            title: "delectus aut autem",
-            completed: false
-        });
-    });
-
-    it("should fail", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl).validate(schema);
-        });
-
-        // Expect the validation to fail the promise
-        await expect(Klaim[apiName][routeName]({id: 15})).rejects.toThrow();
-    });
-
-    it("should reformat if possible", async () => {
-        Api.create(apiName, apiUrl, () => {
-            Route.get(routeName, routeUrl).validate(yup.object().shape({
-                    userId: yup.number().required(),
-                    id: yup.string().required(),
-                    title: yup.string().required(),
-                    completed: yup.boolean().required()
-                })
-            );
-        });
-
-        // Expect the id to be a string
-        expect(await Klaim[apiName][routeName]({id: "1"})).toStrictEqual({
-            userId: 1,
-            id: "1",
-            title: "delectus aut autem",
-            completed: false
-        });
-    });
-});
+import {describe, it} from "vitest";
+import {Api, Klaim, Route} from "../src/index";
+import * as yup from "yup";
+
+const apiName = "testApi";
+const apiUrl = "https://jsonplaceholder.typicode.com";
+
+const routeName = "testRoute";
+const routeUrl = "todos/[id]";
+
+const schema = yup.object().shape({
+    userId: yup.number().required(),
+    id: yup.number().min(1).max(10).required(),
+    title: yup.string().required(),
+    completed: yup.boolean().required()
+});
+
+describe("Validate Yup", async () => {
+    it("should not fail", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl);
+        });
+
+        // Expect the validation to not fail the promise
+        expect(await Klaim[apiName][routeName]({id: 1})).toStrictEqual({
+            userId: 1,
+            id: 1,
+            title: "delectus aut autem",
+            completed: false
+        });
+    });
+
+    it("should fail", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl).validate(schema);
+        });
+
+        // Expect the validation to fail the promise
+        await expect(Klaim[apiName][routeName]({id: 15})).rejects.toThrow();
+    });
+
+    it("should reformat if possible", async () => {
+        Api.create(apiName, apiUrl, () => {
+            Route.get(routeName, routeUrl).validate(yup.object().shape({
+                    userId: yup.number().required(),
+                    id: yup.string().required(),
+                    title: yup.string().required(),
+                    completed: yup.boolean().required()
+                })
+            );
+        });
+
+        // Expect the id to be a string
+        expect(await Klaim[apiName][routeName]({id: "1"})).toStrictEqual({
+            userId: 1,
+            id: "1",
+            title: "delectus aut autem",
+            completed: false
+        });
+    });
+});