@adviser/cement 0.5.11 → 0.5.13

package/esm/evento.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { Evento, EventoResult, EventoOp, EventoType, } from "./evento.js";
+import { Evento, EventoResult, EventoOp, EventoType, EventoSend, } from "./evento.js";
 import { Result } from "./result.js";
 import { Option } from "./option.js";
+import { sleep } from "./promise-sleep.js";
 class ReqResEventoEnDecoder {
     async encode(args) {
         const body = (await args.json());
@@ -136,6 +137,7 @@ describe("Evento", () => {
     const reqRes = new ReqResEventoEnDecoder();
     const evo = new Evento(reqRes);
     const send = new TestSend();
+    const sendEvent = new EventoSend(send);
     evo.push({
         type: EventoType.WildCard,
         hash: "wildcard-handler-first",
@@ -157,7 +159,8 @@ describe("Evento", () => {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 let ret = Result.Ok(EventoResult.Continue);
                 if (v.req.stop) {
                     ret = Result.Ok(EventoResult.Stop);
@@ -188,7 +191,7 @@ describe("Evento", () => {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item: v } = rv.Ok();
                 const ret = Result.Ok(EventoResult.Continue);
                 send.fn("wildcard-second-handle", ctx, v, ret);
                 return ret;
@@ -215,7 +218,8 @@ describe("Evento", () => {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 let ret = Result.Ok(EventoResult.Continue);
                 if (v.req.stop) {
                     ret = Result.Ok(EventoResult.Stop);
@@ -245,7 +249,8 @@ describe("Evento", () => {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 const ret = Result.Ok(EventoResult.Continue);
                 send.fn("regular-second-handle", ctx, v, ret);
                 return ret;
@@ -278,10 +283,11 @@ describe("Evento", () => {
             "wildcard-first-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 1, step: "wildcard-first" })),
         ]);
@@ -289,10 +295,11 @@ describe("Evento", () => {
             "wildcard-first-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, step: "wildcard-first" },
             }),
             {
@@ -310,10 +317,11 @@ describe("Evento", () => {
             "wildcard-second-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 1, step: "wildcard-second" })),
         ]);
@@ -321,13 +329,14 @@ describe("Evento", () => {
             "wildcard-second-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, step: "wildcard-second" },
             }),
-            {
+            Result.Ok({
                 encoderInfo: "test-encoder",
                 req: {
                     step: "wildcard-second",
@@ -335,7 +344,7 @@ describe("Evento", () => {
                     x: 1,
                 },
                 response: "ok",
-            },
+            }),
             Result.Ok(EventoResult.Continue),
         ]);
     });
@@ -358,10 +367,11 @@ describe("Evento", () => {
             "wildcard-first-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 1, stop: true, step: "wildcard-first" })),
         ]);
@@ -369,10 +379,11 @@ describe("Evento", () => {
             "wildcard-first-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 1, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, stop: true, step: "wildcard-first" },
             }),
             {
@@ -408,10 +419,11 @@ describe("Evento", () => {
             "regular-first-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 2, step: "regular-first" })),
         ]);
@@ -419,10 +431,11 @@ describe("Evento", () => {
             "regular-first-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, step: "regular-first" },
             }),
             {
@@ -440,10 +453,11 @@ describe("Evento", () => {
             "regular-second-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 2, step: "regular-second" })),
         ]);
@@ -451,10 +465,11 @@ describe("Evento", () => {
             "regular-second-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, step: "regular-second" },
             }),
             {
@@ -486,10 +501,11 @@ describe("Evento", () => {
             "regular-first-validate",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             Result.Ok(Option.Some({ validated: true, x: 2, stop: true, step: "regular-first" })),
         ]);
@@ -497,10 +513,11 @@ describe("Evento", () => {
             "regular-first-handle",
             expect.objectContaining({
                 ctx: expect.anything(),
+                stats: expect.anything(),
                 enRequest: { x: 2, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, stop: true, step: "regular-first" },
             }),
             {
@@ -516,5 +533,475 @@ describe("Evento", () => {
             Result.Ok(EventoResult.Stop),
         ]);
     });
+    it("validate throw encode error trigger", async () => {
+        class ErrorEncoder {
+            encode(_args) {
+                throw new Error("test encode error");
+            }
+            decode(data) {
+                return Promise.resolve(Result.Ok(JSON.stringify(data)));
+            }
+        }
+        const evo = new Evento(new ErrorEncoder());
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            hash: "regular-handler-0",
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.reject(new Error("test error"));
+            },
+        });
+        const request = new Request("http://example.com", { method: "GET" });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual(["error-handler-0-handle", "error-handler-1-handle"]);
+        expect(send.fn.mock.calls[0][1].error.message).toContain("test encode error");
+        expect(send.fn.mock.calls[0]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                request,
+                error: send.fn.mock.calls[0][1].error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    it("validate result encode error trigger", async () => {
+        class ErrorEncoder {
+            encode(_args) {
+                return Promise.resolve(Result.Err(new Error("test encode error")));
+            }
+            decode(data) {
+                return Promise.resolve(Result.Ok(JSON.stringify(data)));
+            }
+        }
+        const evo = new Evento(new ErrorEncoder());
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            hash: "regular-handler-0",
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.reject(new Error("test error"));
+            },
+        });
+        const request = new Request("http://example.com", { method: "GET" });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual(["error-handler-0-handle", "error-handler-1-handle"]);
+        expect(send.fn.mock.calls[0][1].error.message).toContain("test encode error");
+        expect(send.fn.mock.calls[0]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                request,
+                error: send.fn.mock.calls[0][1].error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    it("validate throw error trigger", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        const error = new Error("test validate error");
+        evo.push({
+            hash: "regular-handler-0",
+            validate: async (ctx) => {
+                send.fn("regular-handler-0-validate", ctx);
+                return Promise.reject(error);
+            },
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.reject(new Error("test error"));
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-handler-0-validate",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+        ]);
+        expect(send.fn.mock.calls[1]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    it("validate result error trigger", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        const error = new Error("test validate error");
+        evo.push({
+            hash: "regular-handler-0",
+            validate: async (ctx) => {
+                send.fn("regular-handler-0-validate", ctx);
+                return Promise.resolve(Result.Err(error));
+            },
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.reject(new Error("test error"));
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-handler-0-validate",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+        ]);
+        expect(send.fn.mock.calls[1]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    it("handle throw error trigger", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        const error = new Error("test handle error");
+        evo.push({
+            hash: "regular-handler-0",
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.reject(error);
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "start",
+            "regular-handler-0-handle",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[2]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+                validated: {
+                    stop: true,
+                    x: 2,
+                },
+            }),
+        ]);
+    });
+    it("handle result error trigger", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new EventoSend(send);
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        const error = new Error("test handle error");
+        evo.push({
+            hash: "regular-handler-0",
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.resolve(Result.Err(error));
+            },
+            post: async (ctx) => {
+                send.fn("regular-handler-0-post", ctx);
+                return Promise.resolve();
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "start",
+            "regular-handler-0-handle",
+            "regular-handler-0-post",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[3]).toEqual([
+            "error-handler-0-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                stats: expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+                validated: {
+                    stop: true,
+                    x: 2,
+                },
+            }),
+        ]);
+    });
+    it("call post", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        evo.push({
+            hash: "regular-handler-0",
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+            post: async (ctx) => {
+                send.fn("regular-handler-0-post", ctx);
+                return Promise.reject(new Error("test post-0 error"));
+            },
+        });
+        evo.push({
+            hash: "regular-handler-1",
+            handle: async (ctx) => {
+                send.fn("regular-handler-1-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        evo.push({
+            hash: "regular-handler-2",
+            handle: async (ctx) => {
+                send.fn("regular-handler-2-handle", ctx);
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+            post: async (ctx) => {
+                send.fn("regular-handler-2-post", ctx);
+                return Promise.resolve();
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "start",
+            "regular-handler-0-handle",
+            "regular-handler-1-handle",
+            "regular-handler-2-handle",
+            "regular-handler-0-post",
+            "regular-handler-2-post",
+            "done",
+        ]);
+    });
+    it("check stat", async () => {
+        const evo = new Evento(reqRes);
+        const send = new TestSend();
+        evo.push({
+            hash: "regular-handler-0",
+            validate: async (ctx) => {
+                send.fn("regular-handler-0-validate", ctx);
+                return sleep(10).then(() => Result.Ok(Option.Some({ x: 2, stop: true })));
+            },
+            handle: async (ctx) => {
+                send.fn("regular-handler-0-handle", ctx);
+                for (let i = 0; i < 3; i++) {
+                    await ctx.send.send(ctx, {
+                        response: "ok0",
+                        req: ctx.validated,
+                        cnt: i,
+                    });
+                }
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+            post: async (ctx) => {
+                send.fn("regular-handler-0-post", ctx);
+                return sleep(10).then(() => {
+                    return;
+                });
+            },
+        });
+        evo.push({
+            hash: "regular-handler-1",
+            handle: async (ctx) => {
+                send.fn("regular-handler-1-handle", ctx);
+                for (let i = 0; i < 3; i++) {
+                    await ctx.send.send(ctx, {
+                        response: "ok1",
+                        req: ctx.validated,
+                        cnt: i,
+                    });
+                }
+                return Promise.resolve(Result.Ok(EventoResult.Continue));
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-handler-0-validate",
+            "start",
+            "regular-handler-0-handle",
+            "send",
+            "send",
+            "send",
+            "regular-handler-1-handle",
+            "send",
+            "send",
+            "send",
+            "regular-handler-0-post",
+            "done",
+        ]);
+        const stats = send.fn.mock.calls[3][1].stats;
+        expect(stats.request.doneTime.getTime()).toBeGreaterThanOrEqual(stats.request.startTime.getTime());
+        expect(stats.encode.doneTime.getTime()).toBeGreaterThanOrEqual(stats.encode.startTime.getTime());
+        expect(stats.handlers.length).toBe(2);
+        for (const hdl of stats.handlers) {
+            expect(hdl.handled.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.handled.startTime.getTime());
+            expect(hdl.handler.hash).toMatch(/regular-handler/);
+            expect(hdl.validated.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.validated.startTime.getTime());
+            expect(hdl.total.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.total.startTime.getTime());
+        }
+        expect(stats.send.doneTime.getTime()).toBeGreaterThanOrEqual(stats.send.startTime.getTime());
+        expect(stats.send.items.length).toBe(6);
+        let sendCount = 0;
+        for (const item of stats.send.items) {
+            expect(item.doneTime.getTime()).toBeGreaterThanOrEqual(item.startTime.getTime());
+            expect(item.item).toEqual(Result.Ok({
+                cnt: sendCount++ % 3,
+                encoderInfo: "test-encoder",
+                req: {
+                    stop: true,
+                    x: 2,
+                },
+                response: `ok${sendCount > 3 ? 1 : 0}`,
+            }));
+        }
+    });
 });
 //# sourceMappingURL=evento.test.js.map