@kcconfigs/vitest 0.0.1 → 0.1.0-beta.0

package/src/utils/defineRoot.test.ts

@@ -0,0 +1,114 @@
+/** biome-ignore-all lint/complexity/useLiteralKeys: Conflict with ts(4111) */
+
+import { describe, expect, test } from "vitest";
+import { defineRoot } from "./defineRoot";
+
+describe("defineRoot", () => {
+	test("should return a configuration object", () => {
+		const config = defineRoot();
+
+		expect(config).toBeDefined();
+		expect(typeof config).toBe("object");
+	});
+
+	test("should include base root configuration", () => {
+		const config = defineRoot();
+
+		expect(config.test).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+		expect(config.test?.restoreMocks).toBe(true);
+		expect(config.test?.mockReset).toBe(true);
+		expect(config.test?.clearMocks).toBe(true);
+	});
+
+	test("should merge custom configuration", () => {
+		const config = defineRoot({
+			test: {
+				environment: "jsdom",
+			},
+		});
+
+		expect(config.test?.environment).toBe("jsdom");
+	});
+
+	test("should preserve base configuration when merging", () => {
+		const config = defineRoot({
+			test: {
+				environment: "jsdom",
+			},
+		});
+
+		expect(config.test?.restoreMocks).toBe(true);
+		expect(config.test?.mockReset).toBe(true);
+	});
+
+	test("should handle multiple configuration overrides", () => {
+		const config = defineRoot(
+			{
+				test: {
+					environment: "jsdom",
+				},
+			},
+			{
+				test: {
+					globals: true,
+				},
+			},
+		);
+
+		expect(config.test?.environment).toBe("jsdom");
+		expect(config.test?.globals).toBe(true);
+		expect(config.test?.restoreMocks).toBe(true);
+	});
+
+	test("should include coverage configuration", () => {
+		const config = defineRoot();
+
+		expect(config.test?.coverage).toBeDefined();
+		expect(config.test?.coverage?.enabled).toBe(true);
+		expect(config.test?.coverage?.provider).toBe("v8");
+	});
+
+	test("should include reporter configuration", () => {
+		const config = defineRoot();
+
+		expect(config.test?.reporters).toBeDefined();
+		expect(config.test?.reporters).toContain("default");
+		expect(config.test?.reporters).toContain("html");
+		expect(config.test?.reporters).toContain("junit");
+	});
+
+	test("should include output file configuration", () => {
+		const config = defineRoot();
+
+		expect(config.test?.outputFile).toBeDefined();
+		if (typeof config.test?.outputFile !== "string") {
+			expect(config.test?.outputFile?.["html"]).toContain(
+				"reports/test-results",
+			);
+			expect(config.test?.outputFile?.["junit"]).toContain(
+				"reports/test-results",
+			);
+		}
+	});
+
+	test("should handle undefined configuration", () => {
+		const config = defineRoot(undefined);
+
+		expect(config).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should override coverage settings", () => {
+		const config = defineRoot({
+			test: {
+				coverage: {
+					enabled: false,
+				},
+			},
+		});
+
+		expect(config.test?.coverage?.enabled).toBe(false);
+		expect(config.test?.coverage?.provider).toBe("v8");
+	});
+});

package/src/utils/defineRoot.ts

@@ -0,0 +1,16 @@
+import { baseRootConfig } from "../constants";
+import type { UserConfig } from "../models";
+import { defineEmptyRoot } from "./defineEmptyRoot";
+
+/**
+ * Defines the root Vitest configuration for the workspace.
+ * Merges the base root configuration with any provided user configuration.
+ *
+ * @param config - Optional user-provided Vitest configuration overrides
+ * @returns The merged root Vitest configuration
+ *
+ * @includeExample
+ */
+export const defineRoot = (...config: Optional<UserConfig>[]): UserConfig => {
+	return defineEmptyRoot(baseRootConfig, ...config);
+};

package/src/utils/mergeConfig.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "vitest";
+import type { AnyConfig, UserConfig } from "../models";
+import { mergeConfig } from "./mergeConfig";
+
+describe("mergeConfig", () => {
+	test("should merge two simple configurations", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+		const addon: AnyConfig = { b: 3, c: 4 };
+
+		const result = mergeConfig(defaults, addon);
+
+		expect(result).toEqual({ a: 1, b: 3, c: 4 });
+	});
+
+	test("should merge multiple configurations", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+		const addon1: AnyConfig = { b: 3, c: 4 };
+		const addon2: AnyConfig = { c: 5, d: 6 };
+
+		const result = mergeConfig(defaults, addon1, addon2);
+
+		expect(result).toEqual({ a: 1, b: 3, c: 5, d: 6 });
+	});
+
+	test("should handle nested configurations", () => {
+		const defaults = { test: { timeout: 1000, retry: 0 } };
+		const addon = { test: { timeout: 5000 } };
+
+		const result = mergeConfig(defaults, addon);
+
+		expect(result).toEqual({
+			test: { timeout: 5000, retry: 0 },
+		});
+	});
+
+	test("should filter out undefined addons", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+		const addon1: AnyConfig = { b: 3 };
+		const addon2 = undefined;
+		const addon3: AnyConfig = { c: 4 };
+
+		const result = mergeConfig(defaults, addon1, addon2, addon3);
+
+		expect(result).toEqual({ a: 1, b: 3, c: 4 });
+	});
+
+	test("should filter out null addons", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+		const addon1: AnyConfig = { b: 3 };
+		const addon2 = null;
+		const addon3: AnyConfig = { c: 4 };
+
+		const result = mergeConfig(defaults, addon1, addon2, addon3);
+
+		expect(result).toEqual({ a: 1, b: 3, c: 4 });
+	});
+
+	test("should not mutate original configurations", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+		const addon: AnyConfig = { b: 3, c: 4 };
+
+		mergeConfig(defaults, addon);
+
+		expect(defaults).toEqual({ a: 1, b: 2 });
+		expect(addon).toEqual({ b: 3, c: 4 });
+	});
+
+	test("should handle empty defaults", () => {
+		const defaults: AnyConfig = {};
+		const addon: AnyConfig = { a: 1, b: 2 };
+
+		const result = mergeConfig(defaults, addon);
+
+		expect(result).toEqual({ a: 1, b: 2 });
+	});
+
+	test("should handle empty addons", () => {
+		const defaults: AnyConfig = { a: 1, b: 2 };
+
+		const result = mergeConfig(defaults);
+
+		expect(result).toEqual({ a: 1, b: 2 });
+	});
+
+	test("should merge array values", () => {
+		const defaults: UserConfig = { test: { reporters: ["default"] } };
+		const addon: AnyConfig = { test: { reporters: ["html", "junit"] } };
+
+		const result = mergeConfig<UserConfig>(defaults, addon);
+
+		expect(result.test?.reporters).toEqual(["default", "html", "junit"]);
+	});
+
+	test("should handle complex vitest configuration", () => {
+		const defaults: AnyConfig = {
+			test: {
+				environment: "node",
+				coverage: {
+					enabled: true,
+					provider: "v8",
+				},
+			},
+		};
+		const addon: AnyConfig = {
+			test: {
+				environment: "jsdom",
+				coverage: {
+					reporter: ["text", "html"],
+				},
+			},
+		};
+
+		const result = mergeConfig(defaults, addon);
+
+		expect(result).toEqual({
+			test: {
+				environment: "jsdom",
+				coverage: {
+					enabled: true,
+					provider: "v8",
+					reporter: ["text", "html"],
+				},
+			},
+		});
+	});
+});

package/src/utils/mergeConfig.ts

@@ -0,0 +1,29 @@
+import { mergeConfig as _mergeConfig } from "vitest/config";
+import type { AnyConfig } from "../models";
+
+/**
+ * Merges multiple configuration objects into a single configuration.
+ * later addons taking precedence over earlier ones.
+ *
+ * No object will be mutated during this process.
+ *
+ * @template C - The configuration object type that extends a Record with string keys
+ * @param defaults - The default configuration object
+ * @param addons - One or more configuration objects to merge into the defaults
+ * @returns The merged configuration object
+ */
+export const mergeConfig = <C extends AnyConfig>(
+	defaults: C,
+	...addons: Optional<C>[]
+): C => {
+	return addons
+		.filter((addon) => addon !== undefined && addon !== null)
+		.reduce(
+			(merged, addon) =>
+				_mergeConfig(
+					merged as Record<string, unknown>,
+					addon as Record<string, unknown>,
+				) as C,
+			defaults,
+		);
+};

package/src/utils/setupMocks.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "vitest";
+import { setupMocks } from "./setupMocks";
+
+describe("setupMocks", () => {
+	test("should return empty array when no flags are set", () => {
+		const result = setupMocks({
+			fs: undefined,
+		});
+
+		expect(result).toEqual([]);
+	});
+
+	test("should return fs mock path when fs flag is true", () => {
+		const result = setupMocks({ fs: true });
+
+		expect(result).toHaveLength(1);
+		expect(result[0]).toContain("__mocks__");
+		expect(result[0]).toContain("fs.ts");
+	});
+
+	test("should return fsPromises mock path when fsPromises flag is true", () => {
+		const result = setupMocks({ fsPromises: true });
+
+		expect(result).toHaveLength(1);
+		expect(result[0]).toContain("__mocks__");
+		expect(result[0]).toContain("fsPromises.ts");
+	});
+
+	test("should return process mock path when process flag is true", () => {
+		const result = setupMocks({ process: true });
+
+		expect(result).toHaveLength(1);
+		expect(result[0]).toContain("__mocks__");
+		expect(result[0]).toContain("process.ts");
+	});
+
+	test("should return os mock path when os flag is true", () => {
+		const result = setupMocks({ os: true, fs: undefined });
+
+		expect(result).toHaveLength(1);
+		expect(result[0]).toContain("__mocks__");
+		expect(result[0]).toContain("os.ts");
+	});
+
+	test("should return multiple mock paths when multiple flags are true", () => {
+		const result = setupMocks({ fs: true, process: true });
+
+		expect(result).toHaveLength(2);
+		expect(result.some((path) => path.includes("fs.ts"))).toBe(true);
+		expect(result.some((path) => path.includes("process.ts"))).toBe(true);
+	});
+
+	test("should return all mock paths when all flags are true", () => {
+		const result = setupMocks({
+			fs: true,
+			fsPromises: true,
+			process: true,
+			os: true,
+		});
+
+		expect(result).toHaveLength(4);
+		expect(result.some((path) => path.includes("fs.ts"))).toBe(true);
+		expect(result.some((path) => path.includes("fsPromises.ts"))).toBe(true);
+		expect(result.some((path) => path.includes("process.ts"))).toBe(true);
+		expect(result.some((path) => path.includes("os.ts"))).toBe(true);
+	});
+
+	test("should ignore flags that are not true", () => {
+		const result = setupMocks({ fs: true });
+
+		expect(result).toHaveLength(1);
+		expect(result[0]).toContain("fs.ts");
+	});
+
+	test("should resolve paths to __mocks__ directory", () => {
+		const result = setupMocks({ fs: true });
+
+		expect(result[0]).toContain("__mocks__");
+		expect(result[0]).toContain("fs.ts");
+	});
+});

package/src/utils/setupMocks.ts

@@ -0,0 +1,22 @@
+import { join } from "node:path";
+
+export interface MockFlag {
+	fs?: true;
+	fsPromises?: true;
+	process?: true;
+	os?: true;
+}
+
+export type MockFlagKey = keyof MockFlag;
+
+const resolvePath = (name: string) => {
+	// import.meta.dirname is resolved to `dist` directory
+	return join(import.meta.dirname, "..", "__mocks__", `${name}.ts`);
+};
+
+export const setupMocks = (flag: MockFlag): string[] => {
+	const keys = Object.keys(flag) as MockFlagKey[];
+	return keys
+		.map((key) => (flag[key] === true ? resolvePath(key) : undefined))
+		.filter((path) => path !== undefined);
+};