Extracted configuration extraction method

Author: Hargne

src/extractConfiguration.test.ts

@@ -0,0 +1,107 @@
+import fs from "fs";
+import extractConfiguration, {
+  sanitizeConfig,
+  toEnvVar,
+} from "./extractConfiguration";
+
+// Mock the functions used for reading files
+jest.mock("fs", () => ({
+  existsSync: jest.fn(),
+  readFileSync: jest.fn(),
+}));
+
+describe("Config Utilities", () => {
+  describe("toEnvVar", () => {
+    it("should convert camelCase to uppercase with underscores and prepend with JEST_HTML_REPORTER_", () => {
+      expect(toEnvVar("statusIgnoreFilter")).toBe(
+        "JEST_HTML_REPORTER_STATUS_IGNORE_FILTER"
+      );
+      expect(toEnvVar("executionTimeWarningThreshold")).toBe(
+        "JEST_HTML_REPORTER_EXECUTION_TIME_WARNING_THRESHOLD"
+      );
+    });
+  });
+
+  describe("readJsonFile", () => {
+    it("should return parsed JSON from file", () => {
+      const mockConfig = { append: true };
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue(
+        JSON.stringify(mockConfig)
+      );
+
+      const result = extractConfiguration({});
+      expect(result.append).toBe(true);
+    });
+
+    it("should return an empty object if file doesn't exist", () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+      (fs.readFileSync as jest.Mock).mockReturnValue(null);
+
+      const result = extractConfiguration({});
+      expect(result).toEqual(expect.objectContaining({}));
+    });
+
+    it("should return an empty object on JSON parse error", () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue("Invalid JSON");
+
+      const result = extractConfiguration({});
+      expect(result).toEqual(expect.objectContaining({}));
+    });
+  });
+
+  describe("sanitizeConfig", () => {
+    it("should sanitize input based on type parsers", () => {
+      const input = {
+        append: "true", // Should be parsed as a boolean
+        dateFormat: "yyyy-MM-dd", // Should be parsed as a string
+      };
+
+      const sanitized = sanitizeConfig(input);
+      expect(sanitized.append).toBe(true); // True, since 'true' is parsed to boolean
+      expect(sanitized.dateFormat).toBe("yyyy-MM-dd");
+    });
+
+    it("should skip invalid values", () => {
+      const input = {
+        append: "invalid", // Should be ignored due to invalid boolean
+        dateFormat: "yyyy-MM-dd", // Should be parsed correctly
+      };
+
+      const sanitized = sanitizeConfig(input);
+      expect(sanitized.append).toBe(false); // Default value
+      expect(sanitized.dateFormat).toBe("yyyy-MM-dd");
+    });
+
+    it("should handle null and undefined", () => {
+      const input = null;
+      const sanitized = sanitizeConfig(input);
+      expect(sanitized).toEqual({});
+    });
+  });
+
+  describe("extractConfiguration", () => {
+    it("should prioritize environment variables over other sources", () => {
+      process.env.JEST_HTML_REPORTER_PAGE_TITLE = "Environment Title";
+      const config = extractConfiguration({ pageTitle: "CLI Title" });
+
+      expect(config.pageTitle).toBe("Environment Title");
+
+      delete process.env.JEST_HTML_REPORTER_PAGE_TITLE; // Clear the env var to avoid side effects
+    });
+
+    it("should use CLI config when no env var is provided", () => {
+      const config = extractConfiguration({ pageTitle: "CLI Title" });
+
+      expect(config.pageTitle).toBe("CLI Title");
+    });
+
+    it("should use default values when no config is provided", () => {
+      const config = extractConfiguration({});
+
+      expect(config.pageTitle).toBe("Test Report");
+      expect(config.dateFormat).toBe("yyyy-mm-dd HH:MM:ss");
+    });
+  });
+});

src/extractConfiguration.ts

@@ -0,0 +1,124 @@
+import path from "path";
+import fs from "fs";
+import { JestHTMLReporterConfiguration } from "./types";
+import { parseBoolean, parseNumber, parseString } from "./utils";
+
+const defaultValues: JestHTMLReporterConfiguration = {
+  append: false,
+  boilerplate: undefined,
+  collapseSuitesByDefault: false,
+  customScriptPath: undefined,
+  dateFormat: "yyyy-mm-dd HH:MM:ss",
+  executionTimeWarningThreshold: 5,
+  includeConsoleLog: false,
+  includeFailureMsg: false,
+  includeStackTrace: true,
+  includeSuiteFailure: false,
+  includeObsoleteSnapshots: false,
+  logo: undefined,
+  outputPath: path.join(process.cwd(), "test-report.html"),
+  pageTitle: "Test Report",
+  sort: undefined,
+  statusIgnoreFilter: undefined,
+  styleOverridePath: undefined,
+  theme: "defaultTheme",
+  useCssFile: false,
+};
+
+// Convert config key to environment variable format
+export function toEnvVar(key: string): string {
+  return `JEST_HTML_REPORTER_${key
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .toUpperCase()}`;
+}
+
+// Read JSON file safely
+export function readJsonFile(filePath: string) {
+  try {
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+  } catch {
+    // Ignore errors
+    return {};
+  }
+  return {};
+}
+
+// Type conversion functions
+const typeParsers: {
+  [key in keyof JestHTMLReporterConfiguration]: (
+    value: unknown
+  ) => string | number | boolean | undefined;
+} = {
+  append: parseBoolean,
+  boilerplate: parseString,
+  collapseSuitesByDefault: parseBoolean,
+  customScriptPath: parseString,
+  dateFormat: parseString,
+  executionTimeWarningThreshold: parseNumber,
+  includeConsoleLog: parseBoolean,
+  includeFailureMsg: parseBoolean,
+  includeStackTrace: parseBoolean,
+  includeSuiteFailure: parseBoolean,
+  includeObsoleteSnapshots: parseBoolean,
+  logo: parseString,
+  outputPath: parseString,
+  pageTitle: parseString,
+  sort: parseString,
+  statusIgnoreFilter: parseString,
+  styleOverridePath: parseString,
+  theme: parseString,
+  useCssFile: parseBoolean,
+};
+
+// Function to clean & validate configuration input
+export function sanitizeConfig(
+  input: unknown
+): Partial<JestHTMLReporterConfiguration> {
+  if (typeof input !== "object" || input === null) {
+    return {};
+  }
+
+  return (
+    Object.keys(defaultValues) as (keyof JestHTMLReporterConfiguration)[]
+  ).reduce((sanitized, key) => {
+    const parser = typeParsers[key];
+    if (parser && typeof parser === "function" && key in input) {
+      const value = parser((input as JestHTMLReporterConfiguration)[key]);
+      if (value !== undefined) {
+        return { ...sanitized, [key]: value };
+      }
+    }
+    return sanitized;
+  }, {});
+}
+
+export default function (cliConfig: unknown): JestHTMLReporterConfiguration {
+  // Read from environment variables
+  const envConfig: Partial<JestHTMLReporterConfiguration> = (
+    Object.keys(defaultValues) as (keyof JestHTMLReporterConfiguration)[]
+  ).reduce((config, key) => {
+    const envKey = toEnvVar(key);
+    if (process.env[envKey] !== undefined) {
+      return { ...config, [key]: process.env[envKey] };
+    }
+    return config;
+  }, {});
+
+  // Read from JSON files
+  const customJsonConfig = readJsonFile(
+    path.join(process.cwd(), "jesthtmlreporter.config.json")
+  );
+  const packageJsonConfig =
+    readJsonFile(path.join(process.cwd(), "package.json"))?.jest || {};
+
+  // Merge configurations in priority order (with sanitization)
+  return {
+    ...defaultValues, // Default values (lowest priority)
+    ...sanitizeConfig(packageJsonConfig), // package.json "jest" section
+    ...sanitizeConfig(customJsonConfig), // Custom JSON config
+    ...sanitizeConfig(cliConfig), // CLI parameters
+    ...sanitizeConfig(envConfig), // Environment variables (highest priority)
+  };
+}