@adviser/cement 0.5.11 → 0.5.13

package/ts/cjs/evento.test.js

@@ -4,6 +4,7 @@ const vitest_1 = require("vitest");
 const evento_js_1 = require("./evento.js");
 const result_js_1 = require("./result.js");
 const option_js_1 = require("./option.js");
+const promise_sleep_js_1 = require("./promise-sleep.js");
 class ReqResEventoEnDecoder {
     async encode(args) {
         const body = (await args.json());
@@ -138,6 +139,7 @@ class TestSend {
     const reqRes = new ReqResEventoEnDecoder();
     const evo = new evento_js_1.Evento(reqRes);
     const send = new TestSend();
+    const sendEvent = new evento_js_1.EventoSend(send);
     evo.push({
         type: evento_js_1.EventoType.WildCard,
         hash: "wildcard-handler-first",
@@ -159,7 +161,8 @@ class TestSend {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 let ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Continue);
                 if (v.req.stop) {
                     ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Stop);
@@ -190,7 +193,7 @@ class TestSend {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item: v } = rv.Ok();
                 const ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Continue);
                 send.fn("wildcard-second-handle", ctx, v, ret);
                 return ret;
@@ -217,7 +220,8 @@ class TestSend {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 let ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Continue);
                 if (v.req.stop) {
                     ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Stop);
@@ -247,7 +251,8 @@ class TestSend {
                 req: ctx.validated,
             })
                 .then((rv) => {
-                const v = rv.Ok();
+                const { item } = rv.Ok();
+                const v = item.Ok();
                 const ret = result_js_1.Result.Ok(evento_js_1.EventoResult.Continue);
                 send.fn("regular-second-handle", ctx, v, ret);
                 return ret;
@@ -280,10 +285,11 @@ class TestSend {
             "wildcard-first-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 1, step: "wildcard-first" })),
         ]);
@@ -291,10 +297,11 @@ class TestSend {
             "wildcard-first-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, step: "wildcard-first" },
             }),
             {
@@ -312,10 +319,11 @@ class TestSend {
             "wildcard-second-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 1, step: "wildcard-second" })),
         ]);
@@ -323,13 +331,14 @@ class TestSend {
             "wildcard-second-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, step: "wildcard-second" },
             }),
-            {
+            result_js_1.Result.Ok({
                 encoderInfo: "test-encoder",
                 req: {
                     step: "wildcard-second",
@@ -337,7 +346,7 @@ class TestSend {
                     x: 1,
                 },
                 response: "ok",
-            },
+            }),
             result_js_1.Result.Ok(evento_js_1.EventoResult.Continue),
         ]);
     });
@@ -360,10 +369,11 @@ class TestSend {
             "wildcard-first-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 1, stop: true, step: "wildcard-first" })),
         ]);
@@ -371,10 +381,11 @@ class TestSend {
             "wildcard-first-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 1, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 1, stop: true, step: "wildcard-first" },
             }),
             {
@@ -410,10 +421,11 @@ class TestSend {
             "regular-first-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 2, step: "regular-first" })),
         ]);
@@ -421,10 +433,11 @@ class TestSend {
             "regular-first-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, step: "regular-first" },
             }),
             {
@@ -442,10 +455,11 @@ class TestSend {
             "regular-second-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 2, step: "regular-second" })),
         ]);
@@ -453,10 +467,11 @@ class TestSend {
             "regular-second-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2 },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, step: "regular-second" },
             }),
             {
@@ -488,10 +503,11 @@ class TestSend {
             "regular-first-validate",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
             }),
             result_js_1.Result.Ok(option_js_1.Option.Some({ validated: true, x: 2, stop: true, step: "regular-first" })),
         ]);
@@ -499,10 +515,11 @@ class TestSend {
             "regular-first-handle",
             vitest_1.expect.objectContaining({
                 ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
                 enRequest: { x: 2, stop: true },
                 encoder: reqRes,
                 request,
-                send,
+                send: sendEvent,
                 validated: { validated: true, x: 2, stop: true, step: "regular-first" },
             }),
             {
@@ -518,5 +535,475 @@ class TestSend {
             result_js_1.Result.Ok(evento_js_1.EventoResult.Stop),
         ]);
     });
+    (0, vitest_1.it)("validate throw encode error trigger", async () => {
+        class ErrorEncoder {
+            encode(_args) {
+                throw new Error("test encode error");
+            }
+            decode(data) {
+                return Promise.resolve(result_js_1.Result.Ok(JSON.stringify(data)));
+            }
+        }
+        const evo = new evento_js_1.Evento(new ErrorEncoder());
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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,
+        });
+        (0, vitest_1.expect)(send.fn.mock.calls.map((i) => i[0])).toEqual(["error-handler-0-handle", "error-handler-1-handle"]);
+        (0, vitest_1.expect)(send.fn.mock.calls[0][1].error.message).toContain("test encode error");
+        (0, vitest_1.expect)(send.fn.mock.calls[0]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                request,
+                error: send.fn.mock.calls[0][1].error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("validate result encode error trigger", async () => {
+        class ErrorEncoder {
+            encode(_args) {
+                return Promise.resolve(result_js_1.Result.Err(new Error("test encode error")));
+            }
+            decode(data) {
+                return Promise.resolve(result_js_1.Result.Ok(JSON.stringify(data)));
+            }
+        }
+        const evo = new evento_js_1.Evento(new ErrorEncoder());
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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,
+        });
+        (0, vitest_1.expect)(send.fn.mock.calls.map((i) => i[0])).toEqual(["error-handler-0-handle", "error-handler-1-handle"]);
+        (0, vitest_1.expect)(send.fn.mock.calls[0][1].error.message).toContain("test encode error");
+        (0, vitest_1.expect)(send.fn.mock.calls[0]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                request,
+                error: send.fn.mock.calls[0][1].error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("validate throw error trigger", async () => {
+        const evo = new evento_js_1.Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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,
+        });
+        (0, vitest_1.expect)(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-handler-0-validate",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+        ]);
+        (0, vitest_1.expect)(send.fn.mock.calls[1]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("validate result error trigger", async () => {
+        const evo = new evento_js_1.Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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_js_1.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,
+        });
+        (0, vitest_1.expect)(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-handler-0-validate",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+        ]);
+        (0, vitest_1.expect)(send.fn.mock.calls[1]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("handle throw error trigger", async () => {
+        const evo = new evento_js_1.Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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,
+        });
+        (0, vitest_1.expect)(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "start",
+            "regular-handler-0-handle",
+            "error-handler-0-handle",
+            "error-handler-1-handle",
+            "done",
+        ]);
+        (0, vitest_1.expect)(send.fn.mock.calls[2]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+                validated: {
+                    stop: true,
+                    x: 2,
+                },
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("handle result error trigger", async () => {
+        const evo = new evento_js_1.Evento(reqRes);
+        const send = new TestSend();
+        const sendEvent = new evento_js_1.EventoSend(send);
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-0",
+            handle: async (ctx) => {
+                send.fn("error-handler-0-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            type: evento_js_1.EventoType.Error,
+            hash: "error-handler-1",
+            handle: async (ctx) => {
+                send.fn("error-handler-1-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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_js_1.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,
+        });
+        (0, vitest_1.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",
+        ]);
+        (0, vitest_1.expect)(send.fn.mock.calls[3]).toEqual([
+            "error-handler-0-handle",
+            vitest_1.expect.objectContaining({
+                ctx: vitest_1.expect.anything(),
+                stats: vitest_1.expect.anything(),
+                encoder: reqRes,
+                enRequest: { x: 2, stop: true },
+                request,
+                error,
+                send: sendEvent,
+                validated: {
+                    stop: true,
+                    x: 2,
+                },
+            }),
+        ]);
+    });
+    (0, vitest_1.it)("call post", async () => {
+        const evo = new evento_js_1.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_js_1.Result.Ok(evento_js_1.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_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        evo.push({
+            hash: "regular-handler-2",
+            handle: async (ctx) => {
+                send.fn("regular-handler-2-handle", ctx);
+                return Promise.resolve(result_js_1.Result.Ok(evento_js_1.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,
+        });
+        (0, vitest_1.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",
+        ]);
+    });
+    (0, vitest_1.it)("check stat", async () => {
+        const evo = new evento_js_1.Evento(reqRes);
+        const send = new TestSend();
+        evo.push({
+            hash: "regular-handler-0",
+            validate: async (ctx) => {
+                send.fn("regular-handler-0-validate", ctx);
+                return (0, promise_sleep_js_1.sleep)(10).then(() => result_js_1.Result.Ok(option_js_1.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_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+            post: async (ctx) => {
+                send.fn("regular-handler-0-post", ctx);
+                return (0, promise_sleep_js_1.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_js_1.Result.Ok(evento_js_1.EventoResult.Continue));
+            },
+        });
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        (0, vitest_1.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;
+        (0, vitest_1.expect)(stats.request.doneTime.getTime()).toBeGreaterThanOrEqual(stats.request.startTime.getTime());
+        (0, vitest_1.expect)(stats.encode.doneTime.getTime()).toBeGreaterThanOrEqual(stats.encode.startTime.getTime());
+        (0, vitest_1.expect)(stats.handlers.length).toBe(2);
+        for (const hdl of stats.handlers) {
+            (0, vitest_1.expect)(hdl.handled.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.handled.startTime.getTime());
+            (0, vitest_1.expect)(hdl.handler.hash).toMatch(/regular-handler/);
+            (0, vitest_1.expect)(hdl.validated.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.validated.startTime.getTime());
+            (0, vitest_1.expect)(hdl.total.doneTime.getTime()).toBeGreaterThanOrEqual(hdl.total.startTime.getTime());
+        }
+        (0, vitest_1.expect)(stats.send.doneTime.getTime()).toBeGreaterThanOrEqual(stats.send.startTime.getTime());
+        (0, vitest_1.expect)(stats.send.items.length).toBe(6);
+        let sendCount = 0;
+        for (const item of stats.send.items) {
+            (0, vitest_1.expect)(item.doneTime.getTime()).toBeGreaterThanOrEqual(item.startTime.getTime());
+            (0, vitest_1.expect)(item.item).toEqual(result_js_1.Result.Ok({
+                cnt: sendCount++ % 3,
+                encoderInfo: "test-encoder",
+                req: {
+                    stop: true,
+                    x: 2,
+                },
+                response: `ok${sendCount > 3 ? 1 : 0}`,
+            }));
+        }
+    });
 });
 //# sourceMappingURL=evento.test.js.map