VIA-866 AS Add tests for client-side logger functionality

Author: anoop-surej-nhs

src/app/_components/client-unhandled-error-logger/ClientUnhandledErrorLogger.tsx

@@ -12,7 +12,6 @@ let router;
 const reportClientSideUnhandledError = (errorEvent: ErrorEvent) => {
   errorEvent.preventDefault();
 
-  //
   const errorContext: ClientSideErrorContext = {
     message: String(errorEvent.message ?? ""),
     filename: String(errorEvent.filename ?? ""),

src/utils/client-side-logger-server-actions/client-side-error-logger.test.ts

@@ -0,0 +1,63 @@
+import { DeployEnvironment } from "@src/types/environments";
+import config from "@src/utils/config";
+import { ClientSideErrorTypes } from "@src/utils/constants";
+import { logger } from "@src/utils/logger";
+import { ConfigMock, configBuilder } from "@test-data/config/builders";
+
+import logClientSideError from "./client-side-error-logger";
+
+jest.mock("@src/utils/logger", () => ({
+  logger: {
+    child: jest.fn().mockReturnValue({
+      error: jest.fn(),
+    }),
+  },
+}));
+
+jest.mock("@src/utils/requestScopedStorageWrapper", () => ({
+  requestScopedStorageWrapper: jest.fn((fn, ...args) => fn(...args)),
+}));
+
+jest.mock("@src/utils/client-side-logger-server-actions/error-utils", () => ({
+  _sanitiseErrorContext: jest.fn((log) => log), // Simple passthrough for testing
+}));
+
+describe("logClientSideError Server Action", () => {
+  const mockConfig = config as ConfigMock;
+  const mockedLog = logger.child({ module: "" });
+
+  beforeEach(() => {
+    const defaultConfig = configBuilder().build();
+    Object.assign(mockConfig, defaultConfig);
+
+    jest.clearAllMocks();
+  });
+
+  it("logs the error with validated type and sanitised context", async () => {
+    const context = { message: "Test error" };
+
+    await logClientSideError(ClientSideErrorTypes.UNHANDLED_ERROR, context);
+
+    expect(mockedLog.error).toHaveBeenCalledWith(
+      {
+        context: { clientSideErrorType: ClientSideErrorTypes.UNHANDLED_ERROR },
+        error: context,
+      },
+      "Client side error occurred",
+    );
+  });
+
+  it("returns true when NOT in production", async () => {
+    Object.assign(mockConfig, { ...mockConfig, DEPLOY_ENVIRONMENT: DeployEnvironment.dev });
+
+    const result = await logClientSideError(ClientSideErrorTypes.UNHANDLED_ERROR);
+    expect(result).toBe(true);
+  });
+
+  it("returns false when in production", async () => {
+    Object.assign(mockConfig, { ...mockConfig, DEPLOY_ENVIRONMENT: DeployEnvironment.prod });
+
+    const result = await logClientSideError(ClientSideErrorTypes.UNHANDLED_ERROR);
+    expect(result).toBe(false);
+  });
+});

src/utils/client-side-logger-server-actions/client-side-error-logger.ts

@@ -1,6 +1,7 @@
 "use server";
 
 import { DeployEnvironment } from "@src/types/environments";
+import { _sanitiseErrorContext } from "@src/utils/client-side-logger-server-actions/error-utils";
 import config from "@src/utils/config";
 import { ClientSideErrorTypes } from "@src/utils/constants";
 import { logger } from "@src/utils/logger";
@@ -9,9 +10,6 @@ import { Logger } from "pino";
 
 const log: Logger = logger.child({ module: "client-side-error-logger" });
 
-const MAX_FIELD_LENGTH = 2000;
-const ALLOWED_CONTEXT_KEYS: string[] = ["message", "stack", "digest", "filename", "lineno", "colno"];
-
 export interface ClientSideErrorContext {
   message?: string;
   stack?: string;
@@ -21,24 +19,6 @@ export interface ClientSideErrorContext {
   colno?: string;
 }
 
-const sanitiseErrorContext = (rawContext?: unknown): Record<string, string> | undefined => {
-  if (rawContext == null || typeof rawContext !== "object") return undefined;
-
-  const sanitisedContext: Record<string, string> = {};
-  const raw = rawContext as Record<string, unknown>;
-
-  for (const key of ALLOWED_CONTEXT_KEYS) {
-    if (key in raw && typeof raw[key] === "string") {
-      sanitisedContext[key] = (raw[key] as string)
-        .slice(0, MAX_FIELD_LENGTH)
-        // Only allow 'tab', 'newline', 'return' control characters
-        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
-    }
-  }
-
-  return Object.keys(sanitisedContext).length > 0 ? sanitisedContext : undefined;
-};
-
 const logClientSideError = async (
   clientSideErrorType: ClientSideErrorTypes,
   errorContext?: ClientSideErrorContext,
@@ -55,7 +35,7 @@ const logClientSideErrorAction = async (
     ? clientSideErrorType
     : ClientSideErrorTypes.UNKNOWN_ERROR_REASON;
 
-  const sanitisedErrorContext = sanitiseErrorContext(rawErrorContext);
+  const sanitisedErrorContext = _sanitiseErrorContext(rawErrorContext);
 
   log.error(
     {

src/utils/client-side-logger-server-actions/error-utils.test.ts

@@ -0,0 +1,72 @@
+import { _sanitiseErrorContext } from "./error-utils";
+
+describe("_sanitiseErrorContext", () => {
+  it("returns undefined for non-object inputs", () => {
+    expect(_sanitiseErrorContext(null)).toBeUndefined();
+    expect(_sanitiseErrorContext(undefined)).toBeUndefined();
+    expect(_sanitiseErrorContext("string error")).toBeUndefined();
+    expect(_sanitiseErrorContext(123)).toBeUndefined();
+  });
+
+  it("should filter out keys that are not in the allowlist", () => {
+    const raw = {
+      message: "Something went wrong",
+      test: "test key",
+    };
+    const result = _sanitiseErrorContext(raw);
+
+    expect(result).toHaveProperty("message");
+    expect(result).not.toHaveProperty("test");
+  });
+
+  it("should only include keys that have string values", () => {
+    const raw = {
+      message: "Valid message",
+      lineno: 42,
+      colno: "10",
+    };
+    const result = _sanitiseErrorContext(raw);
+
+    expect(result).toEqual({
+      message: "Valid message",
+      colno: "10",
+    });
+    expect(result).not.toHaveProperty("lineno");
+  });
+
+  it("should truncate fields longer than 2000 characters", () => {
+    const longString = "a".repeat(3000);
+    const result = _sanitiseErrorContext({ message: longString });
+
+    expect(result?.message).toHaveLength(2000);
+    expect(result?.message).toBe(longString.slice(0, 2000));
+  });
+
+  it("should remove forbidden control characters but keeps tabs and newlines", () => {
+    // \x00 is 'Null Character' (forbidden), \n is 'Newline' (allowed), \t is 'Tab' (allowed)
+    const raw = {
+      message: "Hello\x00World\nThis\tis\rfine",
+    };
+    const result = _sanitiseErrorContext(raw);
+
+    expect(result?.message).toBe("HelloWorld\nThis\tis\rfine");
+  });
+
+  it("should return undefined if the final object is empty", () => {
+    const raw = { someRandomKey: "no allowed keys here" };
+    expect(_sanitiseErrorContext(raw)).toBeUndefined();
+  });
+
+  it("should handle a full valid error context object", () => {
+    const fullContext = {
+      message: "Error message",
+      stack: "Error: message\n at Object.<anonymous>...",
+      digest: "next-digest-123",
+      filename: "index.ts",
+      lineno: "5",
+      colno: "12",
+    };
+    const result = _sanitiseErrorContext(fullContext);
+    expect(result).toEqual(fullContext);
+  });
+});

src/utils/client-side-logger-server-actions/error-utils.ts

@@ -0,0 +1,22 @@
+const MAX_FIELD_LENGTH = 2000;
+const ALLOWED_CONTEXT_KEYS: string[] = ["message", "stack", "digest", "filename", "lineno", "colno"];
+
+const _sanitiseErrorContext = (rawContext?: unknown): Record<string, string> | undefined => {
+  if (rawContext == null || typeof rawContext !== "object") return undefined;
+
+  const sanitisedContext: Record<string, string> = {};
+  const raw = rawContext as Record<string, unknown>;
+
+  for (const key of ALLOWED_CONTEXT_KEYS) {
+    if (key in raw && typeof raw[key] === "string") {
+      sanitisedContext[key] = (raw[key] as string)
+        .slice(0, MAX_FIELD_LENGTH)
+        // Only allow 'tab', 'newline', 'return' control characters
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+    }
+  }
+
+  return Object.keys(sanitisedContext).length > 0 ? sanitisedContext : undefined;
+};
+
+export { _sanitiseErrorContext };