@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

package/src/tracer.test.ts

@@ -1,314 +0,0 @@
-import { Time } from "./time.js";
-import { WebSysAbstraction } from "./web/index.js";
-import { TimeMode } from "./sys-abstraction.js";
-import { TraceNode } from "./tracer.js";
-import { MockLogger } from "./test/mock-logger.js";
-
-describe("trace", () => {
-  let time: Time;
-  let refTime: Time;
-  let trace: TraceNode;
-  const logger = MockLogger().logger.With().Module("trace").Str("value", "important").Logger();
-  beforeEach(() => {
-    time = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
-    trace = TraceNode.root(time, logger);
-    refTime = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
-  });
-  it("a simple trace", () => {
-    expect(
-      trace.span("test", (trace) => {
-        const r1 = trace.span("test.1", () => {
-          return 1;
-        }) as number;
-        const r2 = trace.span("test.2", () => {
-          return 1;
-        }) as number;
-        return r1 + r2;
-      }),
-    ).toBe(2);
-    const childs = Array.from(trace.childs.values());
-    expect(childs.map((v) => v.invokes())).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now().getTime(),
-            result: "success",
-            end: refTime.Now(5).getTime(),
-          },
-        ],
-      },
-    ]);
-    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
-    refTime = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
-    expect(layered.map((v) => v.invokes())).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test.1",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now(2).getTime(),
-            result: "success",
-            end: refTime.Now().getTime(),
-          },
-        ],
-      },
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test.2",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now().getTime(),
-            result: "success",
-            end: refTime.Now(1).getTime(),
-          },
-        ],
-      },
-    ]);
-  });
-
-  it("a async simple trace", async () => {
-    const log = trace.ctx.logger?.With().Str("value", "test").Logger();
-    const ret = await trace.span(trace.ctxWith("test", log), async (trace) => {
-      const r1 = trace.span(trace.ctxWith("test.1"), () => 1) as number;
-      const log2 = trace.ctx.logger?.With().Module("xxx").Str("r2", "test.2").Logger();
-      const r2 = (await trace.span(trace.ctxWith("test.2", log2), async () => {
-        time.Now();
-        await new Promise<void>((resolve) =>
-          setTimeout(() => {
-            time.Now();
-            time.Now();
-            resolve();
-          }, 100),
-        );
-        return 1;
-      })) as number;
-      return r1 + r2;
-    });
-    expect(ret).toBe(2);
-    const childs = Array.from(trace.childs.values());
-    const exp = childs.map((v) => v.invokes());
-    expect(exp).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test",
-          value: "test",
-        },
-        invokations: [
-          {
-            start: refTime.Now().getTime(),
-            result: "success",
-            end: refTime.Now(8).getTime(),
-          },
-        ],
-      },
-    ]);
-    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
-    expect(layered.map((v) => v.invokes())).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test.1",
-          value: "test",
-        },
-        invokations: [
-          {
-            result: "success",
-            start: refTime.Now(-2).getTime(),
-            end: refTime.Now().getTime(),
-          },
-        ],
-      },
-      {
-        ctx: {
-          module: "xxx",
-          r2: "test.2",
-          spanId: "test.2",
-          value: "test",
-        },
-        invokations: [
-          {
-            start: refTime.Now().getTime(),
-            end: refTime.Now(4).getTime(),
-            result: "success",
-          },
-        ],
-      },
-    ]);
-  });
-
-  it("a async exception trace", async () => {
-    const ret = await trace.span("test", async (trace) => {
-      let r1 = 0;
-      let r2 = 0;
-      for (let i = 0; i < 3; i++) {
-        try {
-          r1 += trace.span("test.1", (trace) => {
-            if (i % 2) {
-              throw new Error("test.1");
-            }
-            trace.metrics.get("i.1").add([i]);
-            return 1;
-          }) as number;
-        } catch (e) {
-          if (i % 2) {
-            expect((e as Error).message).toEqual("test.1");
-          } else {
-            assert(false, "should not happen");
-          }
-        }
-        try {
-          r2 += await trace.span("test.2", async (trace) => {
-            time.Now();
-            await new Promise<void>((resolve, reject) =>
-              setTimeout(() => {
-                time.Now();
-                time.Now();
-                if (i % 2) {
-                  trace.metrics.get("i.2").add(i);
-                  resolve();
-                } else {
-                  reject("test.2");
-                }
-              }, 10),
-            );
-            return 1;
-          });
-        } catch (e) {
-          if (i % 2) {
-            assert(false, "should not happen");
-          } else {
-            expect(e).toEqual("test.2");
-          }
-        }
-      }
-      return r1 + r2;
-    });
-    expect(ret).toBe(3);
-    expect(trace.metrics.toJSON()).toEqual({
-      "/test/test.1/i.1": [0, 2],
-      "/test/test.2/i.2": 1,
-    });
-    const childs = Array.from(trace.childs.values());
-    const exp = childs.map((v) => v.invokes());
-    expect(exp).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now(1).getTime(),
-            end: refTime.Now(22).getTime(),
-            result: "success",
-          },
-        ],
-      },
-    ]);
-    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
-    expect(layered.map((v) => v.invokes())).toEqual([
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test.1",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now(-2).getTime(),
-            end: refTime.Now().getTime(),
-            result: "success",
-          },
-          {
-            start: refTime.Now(-9).getTime(),
-            end: refTime.Now().getTime(),
-            result: "error",
-          },
-          {
-            start: refTime.Now(-16).getTime(),
-            end: refTime.Now().getTime(),
-            result: "success",
-          },
-        ],
-        metricRefs: {
-          "/test/test.1/i.1": [0, 2],
-        },
-      },
-      {
-        ctx: {
-          module: "trace",
-          spanId: "test.2",
-          value: "important",
-        },
-        invokations: [
-          {
-            start: refTime.Now(-4).getTime(),
-            end: refTime.Now(4).getTime(),
-            result: "error",
-          },
-          {
-            start: refTime.Now(-11).getTime(),
-            end: refTime.Now(4).getTime(),
-            result: "success",
-          },
-          {
-            start: refTime.Now(-18).getTime(),
-            end: refTime.Now(4).getTime(),
-            result: "error",
-          },
-        ],
-        metricRefs: {
-          "/test/test.2/i.2": 1,
-        },
-      },
-    ]);
-  });
-});
-
-describe("metrics", () => {
-  let time: Time;
-  let trace: TraceNode;
-  // const logger = MockLogger().logger.With().Module("trace").Str("value", "important").Logger()
-  beforeEach(() => {
-    time = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
-    trace = TraceNode.root(time);
-  });
-
-  it("a simple metrics", () => {
-    ["/test", "test", "/test/wurst", "bla"].forEach((path) => {
-      const abs = path.startsWith("/") ? path : "/" + path;
-      expect(trace.metrics.get(path).path).toBe(abs);
-      expect(trace.metrics.get(path).value).toBeFalsy();
-      trace.metrics.get(path).add(4711);
-      expect(trace.metrics.get(path).value).toBe(4711);
-      trace.metrics.get(path).set(undefined);
-    });
-  });
-  it("create metrics path", () => {
-    trace.span("test", (trace) => {
-      trace.span("test.1", (trace) => {
-        trace.metrics.get("m1.1").add(1);
-        trace.metrics.get("/test/test.1/m1.1").add(1);
-        expect(trace.metrics.get("m1.1").path).toBe("/test/test.1/m1.1");
-        expect(trace.metrics.get("m1.1").value).toBe(2);
-      });
-    });
-  });
-  it("typed span promise or literal", async () => {
-    expect(trace.span("test", () => "1")).toBe("1");
-    expect(await trace.span("test", async () => 1)).toBe(1);
-  });
-});

package/src/uri.test.ts

@@ -1,155 +0,0 @@
-import { BuildURI, MutableURL, URI } from "@adviser/cement";
-
-describe("BuildURI", () => {
-  let uri: BuildURI;
-  beforeEach(() => {
-    uri = BuildURI.from(new MutableURL("http://example.com"));
-    uri.hostname("example");
-    uri.setParam("key", "value");
-  });
-
-  it("toString", () => {
-    expect(uri.toString()).toBe("http://example/?key=value");
-  });
-
-  it("build", () => {
-    expect(uri.URI().toString()).toBe("http://example/?key=value");
-  });
-
-  it("defParam", () => {
-    uri.defParam("key", "value2");
-    uri.defParam("key2", "value2");
-    expect(uri.toString()).toBe("http://example/?key=value&key2=value2");
-  });
-
-  it("searchParams sorted in toString", () => {
-    uri.setParam("z", "value");
-    uri.setParam("a", "value");
-    uri.setParam("m", "value");
-    expect(uri.toString()).toBe("http://example/?a=value&key=value&m=value&z=value");
-  });
-});
-
-describe("URI", () => {
-  // static from(strURLUri: string | URL | URI | NullOrUndef, defaultProtocol = "file:"): URI {
-  it("from str with default", () => {
-    const uri = URI.from("/example/wurst");
-    expect(uri.toString()).toBe("file:///example/wurst");
-  });
-  // it("from str defect", () => {
-  //   expect(URI.from("doof:meno")).toBe(null);
-  // })
-  it("from URL str", () => {
-    expect(URI.from("bla://example/com?key=value").toString()).toBe("bla://example/com?key=value");
-  });
-  it("from URL", () => {
-    expect(URI.from(new MutableURL("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
-  });
-  it("from URI", () => {
-    expect(URI.from(URI.from("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
-  });
-  it("from undef", () => {
-    expect(URI.from(null).toString()).toBe("file:///");
-  });
-
-  it("build", () => {
-    expect(URI.from("blix://example.com?key=value").build().toString()).toBe("blix://example.com?key=value");
-  });
-
-  it("clone", () => {
-    expect(URI.from("blix://example.com?key=value").clone().toString()).toBe("blix://example.com?key=value");
-  });
-
-  it("asURL", () => {
-    expect(URI.from("blix://example.com?key=value").asURL().toString()).toBe("blix://example.com?key=value");
-  });
-
-  it("toString", () => {
-    expect(URI.from("blix://example.com?key=value").toString()).toBe("blix://example.com?key=value");
-  });
-
-  it("searchParams sorted in toString", () => {
-    expect(URI.from("blix://example.com?z=value&a=value&m=value").toString()).toBe("blix://example.com?a=value&m=value&z=value");
-  });
-  it("searchParams sorted in asURL", () => {
-    expect(URI.from("blix://example.com?z=value&a=value&m=value").asURL().toString()).toBe(
-      "blix://example.com?a=value&m=value&z=value",
-    );
-  });
-
-  it("merge", () => {
-    expect(URI.merge("blix://example.com?key=value&into=4", "murk://bla/com?key=from&z=value").toString()).toBe(
-      "murk://bla/com?into=4&key=from&z=value",
-    );
-  });
-
-  it("merge empty", () => {
-    expect(URI.merge("blix://example/com?key=value&into=4", "murk://?key=from&z=value").toString()).toBe(
-      "murk://example/com?into=4&key=from&z=value",
-    );
-  });
-
-  it("firefox file relative into", () => {
-    expect(URI.from("file://./dist/tests/key.bag").toString()).toBe("file://./dist/tests/key.bag");
-  });
-
-  it("from empty", () => {
-    expect(URI.merge(`file://./dist/tests/key.bag`, "").toString()).toBe("file://./dist/tests/key.bag");
-  });
-
-  it("merge thing about", () => {
-    const result = URI.merge("./dist/what?byKey=4444", "murk://bla.com?key=from&z=value");
-    expect(result.toString()).toBe("murk://bla.com?byKey=4444&key=from&z=value");
-  });
-
-  it("isURI real", () => {
-    expect(URI.is(URI.from())).toBe(true);
-  });
-  it("isURI fake", () => {
-    expect(
-      URI.is({
-        asURL: () => new URL("http://example.com"),
-        hasParam: () => false,
-        getParam: () => "",
-      }),
-    ).toBe(true);
-  });
-
-  it("safari has a different pathname behavior", () => {
-    // chrome -> new URL("indexdb://fp/?name=test&store=meta").pathname -> //fp/
-    // safari -> new URL("indexdb://fp/?name=test&store=meta").pathname -> /
-    const uri = URI.from("indexdb://fp/?name=test&store=meta");
-    expect(uri.pathname).toBe("fp/");
-  });
-
-  it("passing URL to fetch", async () => {
-    const uri = URI.from("https://jsonplaceholder.typicode.com/todos/1");
-    const res = await fetch(uri.asURL());
-    expect(res.status).toBeGreaterThan(199);
-  });
-
-  it("MutableURL is instance of URL", () => {
-    expect(new MutableURL("http://example.com") instanceof URL).toBe(true);
-  });
-
-  it("file url", () => {
-    const uri = URI.from("file://fp?storagekey=zTvTPEPQRWij8rfb3FrFqBm");
-    expect(uri.pathname).toBe("fp");
-  });
-
-  it("unregistered protocol with hostPart", () => {
-    const withoutHostpart = URI.from("indexdb://fp:bla/test/?name=test&store=meta");
-    expect(() => withoutHostpart.hostname).toThrowError('you can use hostname only if protocol is ["http","https","ws","wss"]');
-  });
-
-  it("register protocol with hostPart", () => {
-    const unreg = URI.protocolHasHostpart("indexdb:");
-    const withHostpart = URI.from("indexdb://fp1:88/test/wurst?name=test&store=meta");
-    expect(withHostpart.host).toBe("fp1:88");
-    expect(withHostpart.pathname).toBe("/test/wurst");
-    const withHostpartNoPath = URI.from("indexdb://fp2:88?name=test&store=meta");
-    expect(withHostpartNoPath.host).toBe("fp2:88");
-    expect(withHostpartNoPath.pathname).toBe("/");
-    unreg();
-  });
-});

package/src/web/web-sys-abstraction.ts

@@ -1,80 +0,0 @@
-import { BaseSysAbstraction, WrapperSysAbstraction, WrapperSysAbstractionParams } from "../base-sys-abstraction.js";
-import { FileService, NamedWritableStream } from "../file-service.js";
-import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, envFactory } from "../sys-env.js";
-import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
-
-class WebFileService implements FileService {
-  get baseDir(): string {
-    throw new Error("basedir-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  create(fname: string): Promise<NamedWritableStream> {
-    throw new Error("create-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  readFileString(fname: string): Promise<string> {
-    throw new Error("readFileString-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  writeFileString(fname: string, content: string): Promise<void> {
-    throw new Error("writeFileString-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  abs(fname: string): string {
-    throw new Error("abs-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  join(...paths: string[]): string {
-    throw new Error("join-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  relative(from: string, to?: string | undefined): string {
-    throw new Error("relative-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  dirname(fname: string): string {
-    throw new Error("dirname-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  basename(fname: string): string {
-    throw new Error("basename-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  nodeImport(fname: string): string {
-    throw new Error("nodeImport-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  isAbsolute(fname: string): boolean {
-    throw new Error("isAbsolute-Method not implemented.");
-  }
-}
-
-class WebSystemService implements SystemService {
-  Env(): Env {
-    return envFactory();
-  }
-  Args(): string[] {
-    throw new Error("Args-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  OnExit(hdl: VoidFunc): VoidFunc {
-    throw new Error("OnExit-Method not implemented.");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Exit(code: number): void {
-    throw new Error("Exit-Method not implemented.");
-  }
-}
-
-let my: BaseSysAbstraction | undefined = undefined;
-export function WebSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
-      FileSystem: new WebFileService(),
-      SystemService: new WebSystemService(),
-    });
-  }
-  return new WrapperSysAbstraction(my, param);
-}