@adviser/cement 0.2.36 → 0.2.38

package/ts/logger.test.js

@@ -1,7 +1,19 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 import { TimeFactory, IsLogger, Level, LevelHandlerImpl, LogCollector, LoggerImpl, logValue, Result, runtimeFn, TimeMode, BuildURI, URI, MutableURL, JSONFormatter, YAMLFormatter, } from "@adviser/cement";
 import { WebSysAbstraction } from "@adviser/cement/web";
 import { stripper } from "./utils/stripper.js";
 describe("TestLogger", () => {
+    var _TestResponse_url;
     let logCollector;
     let logger;
     beforeEach(() => {
@@ -1094,110 +1106,358 @@ describe("TestLogger", () => {
             }),
         ]);
     });
-    it("fetch-formatter", async () => {
-        const result = new Response("body", {
+    class TestResponse extends Response {
+        constructor(body, init) {
+            super(body, init);
+            _TestResponse_url.set(this, void 0);
+            __classPrivateFieldSet(this, _TestResponse_url, (init === null || init === void 0 ? void 0 : init.url) || "", "f");
+        }
+        get url() {
+            return __classPrivateFieldGet(this, _TestResponse_url, "f");
+        }
+    }
+    _TestResponse_url = new WeakMap();
+    describe("fetch-formatter", async () => {
+        const resp = new TestResponse("body", {
             status: 200,
             statusText: "OK",
             headers: new Headers({
                 "Content-Type": "text/html",
                 "X-Test": "test",
             }),
+            url: "https://www.google.com",
         });
-        logger.Error().Any("res", { the: result }).Msg("ok");
-        logger.Error().Http(Result.Ok(result)).Msg("1");
         const req = new Request("https://www.google.com", {
             method: "PUT",
             headers: new Headers({
                 "Content-Type": "text/html",
                 "X-Test": "xtest",
             }),
+            body: "String",
         });
-        logger.Error().Http(result, req, "Https").Msg("1");
-        await logger.Flush();
-        expect(stripper(["isReloadNavigation", "reason", "targetAddressSpace", "attribute", "duplex"], logCollector.Logs(true).map((i) => JSON.parse(i)))).toEqual([
-            {
-                level: "error",
-                res: {
-                    the: {
-                        type: "default",
-                        url: "",
-                        redirected: false,
-                        status: 200,
-                        ok: true,
-                        statusText: "OK",
-                        headers: {
-                            "content-type": "text/html",
-                            "x-test": "test",
+        async function fixupLogs() {
+            await logger.Flush();
+            return stripper(["isReloadNavigation", "reason", "targetAddressSpace", "attribute", "duplex", "cache", "credentials", "destination"], logCollector.Logs(true).map((i) => JSON.parse(i)));
+        }
+        it("res", async () => {
+            logger.Error().Any("res", { the: resp }).Msg("ok-the-res");
+            expect(await fixupLogs()).toEqual([
+                {
+                    level: "error",
+                    res: {
+                        the: {
+                            type: "default",
+                            redirected: false,
+                            status: 200,
+                            ok: true,
+                            statusText: "OK",
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "test",
+                            },
+                            body: ">Stream<",
+                            bodyUsed: false,
                         },
-                        body: ">Stream<",
-                        bodyUsed: false,
                     },
+                    msg: "ok-the-res",
                 },
-                msg: "ok",
-            },
-            {
-                level: "error",
-                Http: {
-                    type: "default",
-                    url: "",
-                    redirected: false,
-                    status: 200,
-                    ok: true,
-                    statusText: "OK",
-                    headers: {
-                        "content-type": "text/html",
-                        "x-test": "test",
+            ]);
+        });
+        it("res", async () => {
+            logger.Error().Any("req", { the: req }).Msg("ok-the-req");
+            expect(await fixupLogs()).toEqual([
+                {
+                    level: "error",
+                    msg: "ok-the-req",
+                    req: {
+                        the: {
+                            body: ">Stream<",
+                            bodyUsed: false,
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "xtest",
+                            },
+                            keepalive: false,
+                            method: "PUT",
+                            mode: "cors",
+                            integrity: "",
+                            isHistoryNavigation: false,
+                            redirect: "follow",
+                            referrer: "about:client",
+                            referrerPolicy: "",
+                            signal: {
+                                aborted: false,
+                                onabort: "null",
+                            },
+                            url: "https://www.google.com/",
+                        },
                     },
-                    body: ">Stream<",
-                    bodyUsed: false,
                 },
-                msg: "1",
-            },
-            {
-                level: "error",
-                Https: {
-                    res: {
-                        type: "default",
-                        url: "",
-                        redirected: false,
-                        status: 200,
-                        ok: true,
-                        statusText: "OK",
+            ]);
+        });
+        it("req-res", async () => {
+            logger
+                .Error()
+                .Any("req-res", { the: { req, res: resp } })
+                .Msg("ok-the-req-res");
+            expect(await fixupLogs()).toEqual([
+                {
+                    level: "error",
+                    msg: "ok-the-req-res",
+                    "req-res": {
+                        the: {
+                            req: {
+                                body: ">Stream<",
+                                bodyUsed: false,
+                                headers: {
+                                    "content-type": "text/html",
+                                    "x-test": "xtest",
+                                },
+                                integrity: "",
+                                isHistoryNavigation: false,
+                                keepalive: false,
+                                method: "PUT",
+                                mode: "cors",
+                                redirect: "follow",
+                                referrer: "about:client",
+                                referrerPolicy: "",
+                                signal: {
+                                    aborted: false,
+                                    onabort: "null",
+                                },
+                                url: "https://www.google.com/",
+                            },
+                            res: {
+                                body: ">Stream<",
+                                bodyUsed: false,
+                                headers: {
+                                    "content-type": "text/html",
+                                    "x-test": "test",
+                                },
+                                ok: true,
+                                redirected: false,
+                                status: 200,
+                                statusText: "OK",
+                                type: "default",
+                            },
+                        },
+                    },
+                },
+            ]);
+        });
+        it("req-res", async () => {
+            logger.Error().Http(Result.Ok(resp)).Msg("-1");
+            expect(await fixupLogs()).toEqual([
+                {
+                    Http: {
+                        body: ">Stream<",
+                        bodyUsed: false,
                         headers: {
                             "content-type": "text/html",
                             "x-test": "test",
                         },
+                        ok: true,
+                        redirected: false,
+                        status: 200,
+                        statusText: "OK",
+                        type: "default",
+                    },
+                    level: "error",
+                    msg: "-1",
+                },
+            ]);
+        });
+        it("0", async () => {
+            logger.Error().Http().Msg("0");
+            expect(await fixupLogs()).toEqual([
+                {
+                    level: "error",
+                    msg: "0",
+                },
+            ]);
+        });
+        it("1", async () => {
+            logger.Error().Http(resp, req, "Https").Msg("1");
+            expect(await fixupLogs()).toEqual([
+                {
+                    Https: {
+                        req: {
+                            body: ">Stream<",
+                            bodyUsed: false,
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "xtest",
+                            },
+                            integrity: "",
+                            isHistoryNavigation: false,
+                            keepalive: false,
+                            method: "PUT",
+                            mode: "cors",
+                            redirect: "follow",
+                            referrer: "about:client",
+                            referrerPolicy: "",
+                            signal: {
+                                aborted: false,
+                                onabort: "null",
+                            },
+                            url: "https://www.google.com/",
+                        },
+                        res: {
+                            body: ">Stream<",
+                            bodyUsed: false,
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "test",
+                            },
+                            ok: true,
+                            redirected: false,
+                            status: 200,
+                            statusText: "OK",
+                            type: "default",
+                        },
+                    },
+                    level: "error",
+                    msg: "1",
+                },
+            ]);
+        });
+        it("1.1", async () => {
+            logger.Error().Http("Yolo", Result.Ok(req), Result.Ok(resp)).Msg("1.1");
+            expect(await fixupLogs()).toEqual([
+                {
+                    Yolo: {
+                        req: {
+                            body: ">Stream<",
+                            bodyUsed: false,
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "xtest",
+                            },
+                            integrity: "",
+                            isHistoryNavigation: false,
+                            keepalive: false,
+                            method: "PUT",
+                            mode: "cors",
+                            redirect: "follow",
+                            referrer: "about:client",
+                            referrerPolicy: "",
+                            signal: {
+                                aborted: false,
+                                onabort: "null",
+                            },
+                            url: "https://www.google.com/",
+                        },
+                        res: {
+                            body: ">Stream<",
+                            bodyUsed: false,
+                            headers: {
+                                "content-type": "text/html",
+                                "x-test": "test",
+                            },
+                            ok: true,
+                            redirected: false,
+                            status: 200,
+                            statusText: "OK",
+                            type: "default",
+                        },
+                    },
+                    level: "error",
+                    msg: "1.1",
+                },
+            ]);
+        });
+        it("1.2", async () => {
+            logger.Error().Http("Yerr", Result.Err("e1"), Result.Err("e2")).Msg("1.2");
+            expect(await fixupLogs()).toEqual([
+                {
+                    error: ["e1", "e2"],
+                    level: "error",
+                    msg: "1.2",
+                },
+            ]);
+        });
+        it("2", async () => {
+            logger.Error().Http(req, "Https").Msg("2");
+            expect(await fixupLogs()).toEqual([
+                {
+                    Https: {
                         body: ">Stream<",
                         bodyUsed: false,
-                    },
-                    req: {
-                        method: "PUT",
-                        url: "https://www.google.com/",
                         headers: {
                             "content-type": "text/html",
                             "x-test": "xtest",
                         },
-                        destination: "",
-                        referrer: "about:client",
-                        referrerPolicy: "",
+                        integrity: "",
+                        isHistoryNavigation: false,
+                        keepalive: false,
+                        method: "PUT",
                         mode: "cors",
-                        credentials: "same-origin",
-                        cache: "default",
                         redirect: "follow",
+                        referrer: "about:client",
+                        referrerPolicy: "",
+                        signal: {
+                            aborted: false,
+                            onabort: "null",
+                        },
+                        url: "https://www.google.com/",
+                    },
+                    level: "error",
+                    msg: "2",
+                },
+            ]);
+        });
+        it("3", async () => {
+            logger.Error().Any("HttpReq", req).Msg("3");
+            expect(await fixupLogs()).toEqual([
+                {
+                    HttpReq: {
+                        body: ">Stream<",
+                        bodyUsed: false,
+                        headers: {
+                            "content-type": "text/html",
+                            "x-test": "xtest",
+                        },
                         integrity: "",
-                        keepalive: false,
                         isHistoryNavigation: false,
+                        keepalive: false,
+                        method: "PUT",
+                        mode: "cors",
+                        redirect: "follow",
+                        referrer: "about:client",
+                        referrerPolicy: "",
                         signal: {
                             aborted: false,
                             onabort: "null",
                         },
-                        body: "null",
+                        url: "https://www.google.com/",
+                    },
+                    level: "error",
+                    msg: "3",
+                },
+            ]);
+        });
+        it("4", async () => {
+            logger.Error().Any("HttpRes", resp).Msg("4");
+            expect(await fixupLogs()).toEqual([
+                {
+                    HttpRes: {
+                        body: ">Stream<",
                         bodyUsed: false,
+                        headers: {
+                            "content-type": "text/html",
+                            "x-test": "test",
+                        },
+                        ok: true,
+                        redirected: false,
+                        status: 200,
+                        statusText: "OK",
+                        type: "default",
                     },
+                    level: "error",
+                    msg: "4",
                 },
-                msg: "1",
-            },
-        ]);
+            ]);
+        });
     });
     it("use toJSON", async () => {
         logger
@@ -1238,5 +1498,24 @@ describe("TestLogger", () => {
             },
         ].map((i) => JSON.stringify(i)));
     });
+    it("if uint8array is json do not hexdump", async () => {
+        logger
+            .Error()
+            .Any("res", new TextEncoder().encode(JSON.stringify({ a: 1, b: { c: "x" } })))
+            .Msg("ok");
+        await logger.Flush();
+        expect(logCollector.Logs()).toEqual([
+            {
+                level: "error",
+                msg: "ok",
+                res: {
+                    a: 1,
+                    b: {
+                        c: "x",
+                    },
+                },
+            },
+        ]);
+    });
 });
 //# sourceMappingURL=logger.test.js.map