@tkeron/tools 0.2.2 → 0.4.0

package/tests/loggerObj.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { logger } from "../src/loggerObj.js";
+import type { Logger } from "../src/loggerObj.js";
+
+describe("Logger interface", () => {
+  it("should have all required methods", () => {
+    expect(logger).toHaveProperty("log");
+    expect(logger).toHaveProperty("error");
+    expect(logger).toHaveProperty("warn");
+    expect(logger).toHaveProperty("info");
+    expect(typeof logger.log).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.info).toBe("function");
+  });
+});
+
+describe("logger.log", () => {
+  let logSpy: any;
+
+  beforeEach(() => {
+    logSpy = spyOn(console, "log");
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("should call console.log with single string", () => {
+    logger.log("test message");
+    expect(logSpy).toHaveBeenCalledWith("test message");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with multiple arguments", () => {
+    logger.log("test", "multiple", "args");
+    expect(logSpy).toHaveBeenCalledWith("test", "multiple", "args");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with number", () => {
+    logger.log(42);
+    expect(logSpy).toHaveBeenCalledWith(42);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with object", () => {
+    const obj = { key: "value" };
+    logger.log(obj);
+    expect(logSpy).toHaveBeenCalledWith(obj);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with array", () => {
+    const arr = [1, 2, 3];
+    logger.log(arr);
+    expect(logSpy).toHaveBeenCalledWith(arr);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with null", () => {
+    logger.log(null);
+    expect(logSpy).toHaveBeenCalledWith(null);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with undefined", () => {
+    logger.log(undefined);
+    expect(logSpy).toHaveBeenCalledWith(undefined);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with boolean", () => {
+    logger.log(true);
+    expect(logSpy).toHaveBeenCalledWith(true);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with mixed types", () => {
+    logger.log("string", 42, { key: "value" }, [1, 2], null, undefined, true);
+    expect(logSpy).toHaveBeenCalledWith(
+      "string",
+      42,
+      { key: "value" },
+      [1, 2],
+      null,
+      undefined,
+      true,
+    );
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with no arguments", () => {
+    logger.log();
+    expect(logSpy).toHaveBeenCalledWith();
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log multiple times independently", () => {
+    logger.log("first");
+    logger.log("second");
+    logger.log("third");
+    expect(logSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it("should call console.log with empty string", () => {
+    logger.log("");
+    expect(logSpy).toHaveBeenCalledWith("");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with zero", () => {
+    logger.log(0);
+    expect(logSpy).toHaveBeenCalledWith(0);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with negative number", () => {
+    logger.log(-42);
+    expect(logSpy).toHaveBeenCalledWith(-42);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with NaN", () => {
+    logger.log(NaN);
+    expect(logSpy).toHaveBeenCalledWith(NaN);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with Infinity", () => {
+    logger.log(Infinity);
+    expect(logSpy).toHaveBeenCalledWith(Infinity);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.error", () => {
+  let errorSpy: any;
+
+  beforeEach(() => {
+    errorSpy = spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  it("should call console.error with single string", () => {
+    logger.error("error message");
+    expect(errorSpy).toHaveBeenCalledWith("error message");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with multiple arguments", () => {
+    logger.error("error", "multiple", "args");
+    expect(errorSpy).toHaveBeenCalledWith("error", "multiple", "args");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with Error object", () => {
+    const error = new Error("test error");
+    logger.error(error);
+    expect(errorSpy).toHaveBeenCalledWith(error);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with null", () => {
+    logger.error(null);
+    expect(errorSpy).toHaveBeenCalledWith(null);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with undefined", () => {
+    logger.error(undefined);
+    expect(errorSpy).toHaveBeenCalledWith(undefined);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with no arguments", () => {
+    logger.error();
+    expect(errorSpy).toHaveBeenCalledWith();
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.warn", () => {
+  let warnSpy: any;
+
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn");
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("should call console.warn with single string", () => {
+    logger.warn("warning message");
+    expect(warnSpy).toHaveBeenCalledWith("warning message");
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with multiple arguments", () => {
+    logger.warn("warn", "multiple", "args");
+    expect(warnSpy).toHaveBeenCalledWith("warn", "multiple", "args");
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with null", () => {
+    logger.warn(null);
+    expect(warnSpy).toHaveBeenCalledWith(null);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with undefined", () => {
+    logger.warn(undefined);
+    expect(warnSpy).toHaveBeenCalledWith(undefined);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with no arguments", () => {
+    logger.warn();
+    expect(warnSpy).toHaveBeenCalledWith();
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.info", () => {
+  let infoSpy: any;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, "info");
+  });
+
+  afterEach(() => {
+    infoSpy.mockRestore();
+  });
+
+  it("should call console.info with single string", () => {
+    logger.info("info message");
+    expect(infoSpy).toHaveBeenCalledWith("info message");
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with multiple arguments", () => {
+    logger.info("info", "multiple", "args");
+    expect(infoSpy).toHaveBeenCalledWith("info", "multiple", "args");
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with null", () => {
+    logger.info(null);
+    expect(infoSpy).toHaveBeenCalledWith(null);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with undefined", () => {
+    logger.info(undefined);
+    expect(infoSpy).toHaveBeenCalledWith(undefined);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with no arguments", () => {
+    logger.info();
+    expect(infoSpy).toHaveBeenCalledWith();
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("Logger type compatibility", () => {
+  it("should be compatible with Logger interface", () => {
+    const testLogger: Logger = logger;
+    expect(testLogger).toBeDefined();
+  });
+
+  it("should allow custom Logger implementation", () => {
+    const customLogger: Logger = {
+      log: () => {},
+      error: () => {},
+      warn: () => {},
+      info: () => {},
+    };
+    expect(customLogger).toBeDefined();
+  });
+});

package/{src → tests}/random.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "bun:test";
-import { rng } from "./random";
+import { rng } from "../src/random.js";
 
 describe("testing rng", () => {
   it("should return the same 10 random numbers for seed=344", () => {

package/tests/silentLogger.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { silentLogger } from "../src/silentLogger.js";
+import type { Logger } from "../src/loggerObj.js";
+
+describe("silentLogger interface", () => {
+  it("should have all required Logger methods", () => {
+    expect(silentLogger).toHaveProperty("log");
+    expect(silentLogger).toHaveProperty("error");
+    expect(silentLogger).toHaveProperty("warn");
+    expect(silentLogger).toHaveProperty("info");
+    expect(typeof silentLogger.log).toBe("function");
+    expect(typeof silentLogger.error).toBe("function");
+    expect(typeof silentLogger.warn).toBe("function");
+    expect(typeof silentLogger.info).toBe("function");
+  });
+
+  it("should be compatible with Logger type", () => {
+    const testLogger: Logger = silentLogger;
+    expect(testLogger).toBeDefined();
+  });
+});
+
+describe("silentLogger.log", () => {
+  let logSpy: any;
+
+  beforeEach(() => {
+    logSpy = spyOn(console, "log");
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("should not call console.log with single string", () => {
+    silentLogger.log("test message");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with multiple arguments", () => {
+    silentLogger.log("test", "multiple", "args");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with object", () => {
+    silentLogger.log({ key: "value" });
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with null", () => {
+    silentLogger.log(null);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with undefined", () => {
+    silentLogger.log(undefined);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with no arguments", () => {
+    silentLogger.log();
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log when called multiple times", () => {
+    silentLogger.log("first");
+    silentLogger.log("second");
+    silentLogger.log("third");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.log("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.log("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.error", () => {
+  let errorSpy: any;
+
+  beforeEach(() => {
+    errorSpy = spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  it("should not call console.error with single string", () => {
+    silentLogger.error("error message");
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with multiple arguments", () => {
+    silentLogger.error("error", "multiple", "args");
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with Error object", () => {
+    silentLogger.error(new Error("test error"));
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with null", () => {
+    silentLogger.error(null);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with undefined", () => {
+    silentLogger.error(undefined);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with no arguments", () => {
+    silentLogger.error();
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.error("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.error("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.warn", () => {
+  let warnSpy: any;
+
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn");
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("should not call console.warn with single string", () => {
+    silentLogger.warn("warning message");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with multiple arguments", () => {
+    silentLogger.warn("warn", "multiple", "args");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with null", () => {
+    silentLogger.warn(null);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with undefined", () => {
+    silentLogger.warn(undefined);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with no arguments", () => {
+    silentLogger.warn();
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.warn("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.warn("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.info", () => {
+  let infoSpy: any;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, "info");
+  });
+
+  afterEach(() => {
+    infoSpy.mockRestore();
+  });
+
+  it("should not call console.info with single string", () => {
+    silentLogger.info("info message");
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with multiple arguments", () => {
+    silentLogger.info("info", "multiple", "args");
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with null", () => {
+    silentLogger.info(null);
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with undefined", () => {
+    silentLogger.info(undefined);
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with no arguments", () => {
+    silentLogger.info();
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.info("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.info("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger behavior", () => {
+  it("should not produce any console output when all methods are called", () => {
+    const logSpy = spyOn(console, "log");
+    const errorSpy = spyOn(console, "error");
+    const warnSpy = spyOn(console, "warn");
+    const infoSpy = spyOn(console, "info");
+
+    silentLogger.log("test");
+    silentLogger.error("test");
+    silentLogger.warn("test");
+    silentLogger.info("test");
+
+    expect(logSpy).not.toHaveBeenCalled();
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(warnSpy).not.toHaveBeenCalled();
+    expect(infoSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+    infoSpy.mockRestore();
+  });
+});

package/{src → tests}/stack.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "bun:test";
-import { getFIFO } from "./stack";
-import { getLIFO } from "./stack";
+import { getFIFO } from "../src/stack.js";
+import { getLIFO } from "../src/stack.js";
 
 describe("LIFO stack tests", () => {
   it("should create an empty lifo stack", () => {