Simplify tests

Author: EhabY

test/unit/logging/formatters.test.ts

@@ -17,7 +17,7 @@ describe("Logging formatters", () => {
 		expect(formatTime(60000)).toBe("1.00m");
 		expect(formatTime(150000)).toBe("2.50m");
 		expect(formatTime(3600000)).toBe("1.00h");
-		expect(formatTime(7200000)).toBe("2.00h");
+		expect(formatTime(7255000)).toBe("2.02h");
 	});
 
 	describe("formatMethod", () => {
@@ -28,7 +28,7 @@ describe("Logging formatters", () => {
 			expect(formatMethod("delete")).toBe("DELETE");
 		});
 
-		it("defaults to GET for undefined", () => {
+		it("defaults to GET for falsy values", () => {
 			expect(formatMethod(undefined)).toBe("GET");
 			expect(formatMethod("")).toBe("GET");
 		});
@@ -45,14 +45,17 @@ describe("Logging formatters", () => {
 			expect(result).toContain("?");
 		});
 
-		it("calculates size for strings", () => {
-			const result = formatContentLength({}, "hello");
-			expect(result).toContain("5 B");
-		});
-
-		it("calculates size for buffers", () => {
-			const result = formatContentLength({}, Buffer.from("test"));
-			expect(result).toContain("4 B");
+		it.each([
+			["hello", 5],
+			[Buffer.from("test"), 4],
+			[123, 8],
+			[false, 8],
+			[BigInt(1234), 4],
+			[null, 0],
+			[undefined, 0],
+		])("calculates size for %s", (data: unknown, bytes: number) => {
+			const result = formatContentLength({}, data);
+			expect(result).toContain(`${bytes} B`);
 		});
 
 		it("estimates size for objects", () => {
@@ -66,11 +69,6 @@ describe("Logging formatters", () => {
 			const result = formatContentLength({}, circular);
 			expect(result).toMatch(/~\d+/);
 		});
-
-		it("handles null and undefined", () => {
-			expect(formatContentLength({}, null)).toContain("0");
-			expect(formatContentLength({}, undefined)).toContain("0");
-		});
 	});
 
 	describe("formatUri", () => {

test/unit/logging/httpLogger.test.ts

@@ -76,14 +76,14 @@ describe("REST HTTP Logger", () => {
 		it("distinguishes between network errors and response errors", () => {
 			const logger = createMockLogger();
 
-			const networkError = new AxiosError("Network Error", "ECONNREFUSED");
+			const networkError = new AxiosError("Some Network Error", "ECONNREFUSED");
 			networkError.config = {
 				metadata: createRequestMeta(),
 			} as RequestConfigWithMeta;
 
 			logError(logger, networkError, HttpClientLogLevel.BASIC);
 			expect(logger.error).toHaveBeenCalledWith(
-				expect.stringContaining("Network Error"),
+				expect.stringContaining("Some Network Error"),
 			);
 
 			// Response error (4xx/5xx)
@@ -96,6 +96,9 @@ describe("REST HTTP Logger", () => {
 
 			logError(logger, responseError, HttpClientLogLevel.BASIC);
 			expect(logger.error).toHaveBeenCalledWith(expect.stringContaining("400"));
+			expect(logger.error).toHaveBeenCalledWith(
+				expect.stringContaining("Bad Request"),
+			);
 		});
 
 		it("handles non-Axios errors", () => {

test/unit/logging/utils.test.ts

@@ -18,82 +18,50 @@ describe("Logging utils", () => {
 	});
 
 	describe("sizeOf", () => {
-		describe("primitive types", () => {
-			it("returns 0 for null and undefined", () => {
-				expect(sizeOf(null)).toBe(0);
-				expect(sizeOf(undefined)).toBe(0);
-			});
-
-			it("returns fixed size for numbers and booleans", () => {
-				// Numbers and booleans typically use 8 bytes
-				expect(sizeOf(42)).toBeGreaterThan(0);
-				expect(sizeOf(3.14)).toBeGreaterThan(0);
-				expect(sizeOf(true)).toBeGreaterThan(0);
-				expect(sizeOf(false)).toBeGreaterThan(0);
-
-				// They should all be the same size
-				expect(sizeOf(42)).toBe(sizeOf(3.14));
-				expect(sizeOf(true)).toBe(sizeOf(false));
-			});
-
-			it("calculates byte length for strings", () => {
-				expect(sizeOf("hello")).toBe(5);
-				expect(sizeOf("")).toBe(0);
-				// Unicode characters use multiple bytes
-				expect(sizeOf("✓")).toBeGreaterThan(1);
-				expect(sizeOf("unicode: ✓")).toBeGreaterThan(10);
-			});
-
-			it("calculates byte length for bigints", () => {
-				expect(sizeOf(BigInt(12345))).toBe(5);
-				expect(sizeOf(BigInt(0))).toBe(1);
-			});
-		});
-
-		describe("buffer types", () => {
-			it("returns byte length for Buffer", () => {
-				expect(sizeOf(Buffer.from("test"))).toBe(4);
-				expect(sizeOf(Buffer.alloc(100))).toBe(100);
-				expect(sizeOf(Buffer.from([]))).toBe(0);
-			});
-
-			it("returns byte length for typed arrays", () => {
-				expect(sizeOf(new ArrayBuffer(50))).toBe(50);
-				expect(sizeOf(new Uint8Array([1, 2, 3, 4]))).toBe(4);
-				expect(sizeOf(new Int32Array([1, 2, 3]))).toBe(12); // 3 * 4 bytes
-				expect(sizeOf(new Float64Array([1.0, 2.0]))).toBe(16); // 2 * 8 bytes
-			});
+		it.each([
+			// Primitives return a fixed value
+			[null, 0],
+			[undefined, 0],
+			[42, 8],
+			[3.14, 8],
+			[false, 8],
+			// Strings
+			["hello", 5],
+			["✓", 3],
+			["unicode: ✓", 12],
+			// Buffers
+			[Buffer.from("test"), 4],
+			[BigInt(12345), 5],
+			[BigInt(0), 1],
+			[Buffer.alloc(100), 100],
+			[Buffer.from([]), 0],
+			// Typed-arrays
+			[new ArrayBuffer(50), 50],
+			[new Uint8Array([1, 2, 3, 4]), 4],
+			[new Int32Array([1, 2, 3]), 12],
+			[new Float64Array([1.0, 2.0]), 16],
+			// Objects/untyped-arrays return undefined
+			[{ size: 1024 }, 1024],
+			[{ size: 0 }, 0],
+			[{ size: "not a number" }, undefined],
+			[[], undefined],
+			[[1, 2, 3], undefined],
+			[["a", "b", "c"], undefined],
+			[{}, undefined],
+			[{ foo: "bar" }, undefined],
+			[{ nested: { value: 123 } }, undefined],
+		])("returns size for %s", (data: unknown, bytes: number | undefined) => {
+			expect(sizeOf(data)).toBe(bytes);
 		});
 
-		describe("objects and arrays", () => {
-			it("returns size property if available", () => {
-				expect(sizeOf({ size: 1024 })).toBe(1024);
-				expect(sizeOf({ size: 0 })).toBe(0);
-				// Only use size if it's a number
-				expect(sizeOf({ size: "not a number" })).toBeUndefined();
-			});
-
-			it("returns undefined for arrays without size", () => {
-				expect(sizeOf([])).toBeUndefined();
-				expect(sizeOf([1, 2, 3])).toBeUndefined();
-				expect(sizeOf(["a", "b", "c"])).toBeUndefined();
-			});
-
-			it("returns undefined for plain objects without size", () => {
-				expect(sizeOf({})).toBeUndefined();
-				expect(sizeOf({ foo: "bar" })).toBeUndefined();
-				expect(sizeOf({ nested: { value: 123 } })).toBeUndefined();
-			});
-
-			it("handles circular references safely", () => {
-				const circular: Record<string, unknown> = { a: 1 };
-				circular.self = circular;
-				expect(sizeOf(circular)).toBeUndefined();
+		it("handles circular references safely", () => {
+			const circular: Record<string, unknown> = { a: 1 };
+			circular.self = circular;
+			expect(sizeOf(circular)).toBeUndefined();
 
-				const arr: unknown[] = [1, 2, 3];
-				arr.push(arr);
-				expect(sizeOf(arr)).toBeUndefined();
-			});
+			const arr: unknown[] = [1, 2, 3];
+			arr.push(arr);
+			expect(sizeOf(arr)).toBeUndefined();
 		});
 	});
 

test/unit/logging/wsLogger.test.ts

@@ -26,7 +26,7 @@ describe("WS Logger", () => {
 		const wsLogger = new WsLogger(logger, "wss://example.com");
 
 		wsLogger.logOpen();
-		wsLogger.logMessage({ complex: "object" }); // Unknown size
+		wsLogger.logMessage({ complex: "object" }); // Unknown size - no estimation
 		wsLogger.logMessage("known");
 		wsLogger.logClose();
 
@@ -49,13 +49,13 @@ describe("WS Logger", () => {
 		const wsLogger = new WsLogger(logger, "wss://example.com");
 
 		wsLogger.logOpen();
-		for (let i = 0; i < 1500; i++) {
+		for (let i = 0; i < 1100; i++) {
 			wsLogger.logMessage("x");
 		}
 		wsLogger.logClose();
 
 		expect(logger.trace).toHaveBeenLastCalledWith(
-			expect.stringMatching(/1[.,]5K\s*msgs/),
+			expect.stringMatching(/1[.,]1K\s*msgs/),
 		);
 	});