@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/route-testing/domain/models/index.ts

@@ -0,0 +1,217 @@
+import type {
+	RouteConfig,
+	RouteMatch,
+	RouteParams,
+} from "../../../../shared/types";
+
+// ============================================
+// ROUTE TESTING TYPES
+// ============================================
+
+export type TestRoute = {
+	readonly path: string;
+	readonly params?: RouteParams;
+};
+
+export type TestingState = {
+	readonly routes: readonly RouteConfig[];
+	readonly testResults: readonly TestResult[];
+};
+
+export type TestResult = {
+	readonly path: string;
+	readonly success: boolean;
+	readonly error?: string;
+};
+
+// ============================================
+// CONTRACT TESTING TYPES
+// ============================================
+
+export interface RouteContract<TParams extends RouteParams = RouteParams> {
+	readonly path: string;
+	readonly paramsSchema: Readonly<Record<keyof TParams, ParamSchema>>;
+	readonly searchParamsSchema?: Readonly<Record<string, ParamSchema>>;
+	readonly loaderSchema?: LoaderSchema;
+}
+
+export interface ParamSchema {
+	readonly type: "string" | "number" | "boolean" | "uuid" | "email";
+	readonly required: boolean;
+	readonly pattern?: RegExp;
+	readonly enum?: readonly string[];
+}
+
+export interface LoaderSchema {
+	readonly returnType: string;
+	readonly requiredFields: readonly string[];
+}
+
+export interface ContractViolation {
+	readonly field: string;
+	readonly expected: string;
+	readonly received: unknown;
+	readonly message: string;
+}
+
+export interface ContractTestResult {
+	readonly valid: boolean;
+	readonly violations: readonly ContractViolation[];
+}
+
+// ============================================
+// E2E TESTING TYPES
+// ============================================
+
+export interface E2ETestStep {
+	readonly action: "navigate" | "click" | "fill" | "wait" | "assert";
+	readonly selector?: string;
+	readonly value?: string;
+	readonly assertion?: string;
+	readonly timeout?: number;
+}
+
+export interface E2ETest {
+	readonly name: string;
+	readonly description: string;
+	readonly route: string;
+	readonly steps: readonly E2ETestStep[];
+	readonly expectedResult: string;
+}
+
+export interface E2ETestResult {
+	readonly testName: string;
+	readonly success: boolean;
+	readonly duration: number;
+	readonly error?: string;
+	readonly steps: readonly {
+		readonly step: E2ETestStep;
+		readonly success: boolean;
+		readonly error?: string;
+	}[];
+}
+
+export type E2ETestingState = {
+	readonly tests: readonly E2ETest[];
+	readonly results: readonly E2ETestResult[];
+};
+
+// ============================================
+// PURE FUNCTIONS - ROUTE TESTING
+// ============================================
+
+export const createTestingState = (routes: RouteConfig[]): TestingState => {
+	return Object.freeze({
+		routes: Object.freeze(routes),
+		testResults: Object.freeze([]),
+	});
+};
+
+export const mockRouteMatch = (
+	path: string,
+	params: RouteParams = {},
+): RouteMatch => {
+	return Object.freeze({
+		path,
+		params,
+		searchParams: Object.freeze({}),
+	});
+};
+
+export const assertRouteMatch = (
+	result: import("../../../../shared/types").Result<RouteMatch>,
+	expectedPath: string,
+): boolean => {
+	if (!result.success) {
+		return false;
+	}
+	return result.data.path === expectedPath;
+};
+
+// ============================================
+// PURE FUNCTIONS - CONTRACT TESTING
+// ============================================
+
+export const createParamSchema = (
+	type: ParamSchema["type"],
+	options: Partial<ParamSchema> = {},
+): ParamSchema => {
+	return Object.freeze({
+		type,
+		required: options.required ?? true,
+		...(options.pattern !== undefined && { pattern: options.pattern }),
+		...(options.enum !== undefined && { enum: options.enum }),
+	});
+};
+
+export const createRouteContract = <TParams extends RouteParams>(
+	path: string,
+	paramsSchema: Record<keyof TParams, ParamSchema>,
+	options: Partial<RouteContract<TParams>> = {},
+): RouteContract<TParams> => {
+	return Object.freeze({
+		path,
+		paramsSchema: Object.freeze(paramsSchema),
+		...(options.searchParamsSchema !== undefined && {
+			searchParamsSchema: Object.freeze(options.searchParamsSchema),
+		}),
+		...(options.loaderSchema !== undefined && {
+			loaderSchema: options.loaderSchema,
+		}),
+	});
+};
+
+// ============================================
+// PURE FUNCTIONS - E2E TESTING
+// ============================================
+
+export const createE2ETestingState = (): E2ETestingState => {
+	return Object.freeze({
+		tests: Object.freeze([]),
+		results: Object.freeze([]),
+	});
+};
+
+export const createTestStep = (
+	action: E2ETestStep["action"],
+	options: Partial<E2ETestStep> = {},
+): E2ETestStep => {
+	return Object.freeze({
+		action,
+		...options,
+	});
+};
+
+export const createE2ETest = (
+	name: string,
+	route: string,
+	steps: E2ETestStep[],
+	description = "",
+	expectedResult = "",
+): E2ETest => {
+	return Object.freeze({
+		name,
+		description,
+		route,
+		steps: Object.freeze(steps),
+		expectedResult,
+	});
+};
+
+export const generateTestFromRoute = (route: RouteConfig): E2ETest => {
+	return createE2ETest(
+		`Test ${route.path}`,
+		route.path,
+		[
+			createTestStep("navigate", { value: route.path }),
+			createTestStep("wait", { timeout: 1000 }),
+			createTestStep("assert", { assertion: "Page loaded successfully" }),
+		],
+		`E2E test for route ${route.path}`,
+		"Page should load without errors",
+	);
+};
+
+export const generateTestsFromRoutes = (routes: RouteConfig[]): E2ETest[] => {
+	return routes.map(generateTestFromRoute);
+};

package/src/router/modules/route-testing/domain/operations/contract-testing-operations.ts

@@ -0,0 +1,239 @@
+import type { RouteMatch, RouteParams } from "../../../../shared/types";
+import type { ContractTestResult, RouteContract } from "../models";
+
+export const validateParams = <TParams extends RouteParams>(
+	contract: RouteContract<TParams>,
+	params: TParams,
+): ContractTestResult => {
+	const violations: import("../models").ContractViolation[] = [];
+
+	for (const [key, schema] of Object.entries(contract.paramsSchema)) {
+		const value = params[key as keyof TParams];
+
+		// Check required
+		if (schema.required && value === undefined) {
+			violations.push({
+				field: key,
+				expected: `${schema.type} (required)`,
+				received: value,
+				message: `Parameter '${key}' is required but was not provided`,
+			});
+			continue;
+		}
+
+		// Skip validation if not required and not provided
+		if (!schema.required && value === undefined) {
+			continue;
+		}
+
+		// Type validation
+		const typeError = validateType(key, schema, value);
+		if (typeError) {
+			violations.push(typeError);
+		}
+
+		// Pattern validation
+		if (schema.pattern && typeof value === "string") {
+			if (!schema.pattern.test(value)) {
+				violations.push({
+					field: key,
+					expected: schema.pattern.toString(),
+					received: value,
+					message: `Parameter '${key}' does not match required pattern`,
+				});
+			}
+		}
+
+		// Enum validation
+		if (schema.enum && typeof value === "string") {
+			if (!schema.enum.includes(value)) {
+				violations.push({
+					field: key,
+					expected: schema.enum.join(" | "),
+					received: value,
+					message: `Parameter '${key}' must be one of: ${schema.enum.join(", ")}`,
+				});
+			}
+		}
+	}
+
+	return {
+		valid: violations.length === 0,
+		violations: Object.freeze(violations),
+	};
+};
+
+export const validateSearchParams = (
+	contract: RouteContract,
+	searchParams: Record<string, string>,
+): ContractTestResult => {
+	const violations: import("../models").ContractViolation[] = [];
+
+	if (!contract.searchParamsSchema) {
+		return { valid: true, violations: Object.freeze([]) };
+	}
+
+	for (const [key, schema] of Object.entries(contract.searchParamsSchema)) {
+		const value = searchParams[key];
+
+		// Check required
+		if (schema.required && value === undefined) {
+			violations.push({
+				field: key,
+				expected: `${schema.type} (required)`,
+				received: value,
+				message: `Search parameter '${key}' is required but was not provided`,
+			});
+			continue;
+		}
+
+		// Skip validation if not required and not provided
+		if (!schema.required && value === undefined) {
+			continue;
+		}
+
+		// Type validation
+		const typeError = validateType(key, schema, value);
+		if (typeError) {
+			violations.push(typeError);
+		}
+	}
+
+	return {
+		valid: violations.length === 0,
+		violations: Object.freeze(violations),
+	};
+};
+
+export const validateLoader = (
+	contract: RouteContract,
+	loaderData: unknown,
+): ContractTestResult => {
+	const violations: import("../models").ContractViolation[] = [];
+
+	if (!contract.loaderSchema) {
+		return { valid: true, violations: Object.freeze([]) };
+	}
+
+	// Check if loader data is an object
+	if (typeof loaderData !== "object" || loaderData === null) {
+		violations.push({
+			field: "loader",
+			expected: "object",
+			received: typeof loaderData,
+			message: "Loader data must be an object",
+		});
+		return { valid: false, violations: Object.freeze(violations) };
+	}
+
+	// Check required fields
+	for (const field of contract.loaderSchema.requiredFields) {
+		if (!(field in loaderData)) {
+			violations.push({
+				field,
+				expected: "present",
+				received: undefined,
+				message: `Required field '${field}' is missing from loader data`,
+			});
+		}
+	}
+
+	return {
+		valid: violations.length === 0,
+		violations: Object.freeze(violations),
+	};
+};
+
+export const validateMatch = <TParams extends RouteParams>(
+	contract: RouteContract<TParams>,
+	match: RouteMatch,
+): ContractTestResult => {
+	const violations: import("../models").ContractViolation[] = [];
+
+	// Validate params
+	const paramsResult = validateParams(contract, match.params);
+	violations.push(...paramsResult.violations);
+
+	// Validate search params
+	if (match.searchParams) {
+		const searchResult = validateSearchParams(
+			contract,
+			match.searchParams as Record<string, string>,
+		);
+		violations.push(...searchResult.violations);
+	}
+
+	return {
+		valid: violations.length === 0,
+		violations: Object.freeze(violations),
+	};
+};
+
+const validateType = (
+	field: string,
+	schema: import("../models").ParamSchema,
+	value: unknown,
+): import("../models").ContractViolation | null => {
+	switch (schema.type) {
+		case "string":
+			if (typeof value !== "string") {
+				return {
+					field,
+					expected: "string",
+					received: typeof value,
+					message: `Field '${field}' must be a string`,
+				};
+			}
+			break;
+		case "number":
+			if (typeof value !== "number" || Number.isNaN(value)) {
+				return {
+					field,
+					expected: "number",
+					received: typeof value,
+					message: `Field '${field}' must be a number`,
+				};
+			}
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") {
+				return {
+					field,
+					expected: "boolean",
+					received: typeof value,
+					message: `Field '${field}' must be a boolean`,
+				};
+			}
+			break;
+		case "uuid":
+			if (
+				typeof value !== "string" ||
+				!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+					value,
+				)
+			) {
+				return {
+					field,
+					expected: "uuid",
+					received: value,
+					message: `Field '${field}' must be a valid UUID`,
+				};
+			}
+			break;
+		case "email":
+			if (
+				typeof value !== "string" ||
+				!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+			) {
+				return {
+					field,
+					expected: "email",
+					received: value,
+					message: `Field '${field}' must be a valid email address`,
+				};
+			}
+			break;
+	}
+
+	return null;
+};

package/src/router/modules/route-testing/domain/operations/e2e-testing-operations.ts

@@ -0,0 +1,167 @@
+import type { E2ETest, E2ETestingState, E2ETestResult } from "../models";
+
+export const addTest = (
+	state: E2ETestingState,
+	test: E2ETest,
+): E2ETestingState => {
+	return {
+		...state,
+		tests: [...state.tests, test],
+	};
+};
+
+export const runTest = async (
+	test: E2ETest,
+	startTime: number,
+	endTime: number,
+): Promise<E2ETestResult> => {
+	const stepResults: {
+		readonly step: import("../models").E2ETestStep;
+		readonly success: boolean;
+		readonly error?: string;
+	}[] = [];
+
+	for (const step of test.steps) {
+		try {
+			await executeStep(step);
+			stepResults.push({ step, success: true });
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			stepResults.push({ step, success: false, error: errorMessage });
+		}
+	}
+
+	const duration = endTime - startTime;
+	const allStepsSucceeded = stepResults.every((r) => r.success);
+	const firstError = stepResults.find((r) => !r.success)?.error;
+
+	const result: E2ETestResult = {
+		testName: test.name,
+		success: allStepsSucceeded,
+		duration,
+		steps: Object.freeze(stepResults),
+		...(firstError !== undefined && { error: firstError }),
+	};
+
+	return result;
+};
+
+export const runAllTests = async (
+	state: E2ETestingState,
+	startTime: number,
+	endTime: number,
+): Promise<E2ETestResult[]> => {
+	const results: E2ETestResult[] = [];
+
+	for (const test of state.tests) {
+		const result = await runTest(test, startTime, endTime);
+		results.push(result);
+	}
+
+	return [...results] as E2ETestResult[];
+};
+
+const executeStep = async (
+	step: import("../models").E2ETestStep,
+): Promise<void> => {
+	switch (step.action) {
+		case "navigate":
+			await navigate(step.value || "");
+			break;
+		case "click":
+			await click(step.selector || "");
+			break;
+		case "fill":
+			await fill(step.selector || "", step.value || "");
+			break;
+		case "wait":
+			await wait(step.timeout || 1000);
+			break;
+		case "assert":
+			await assert(step.assertion || "");
+			break;
+	}
+};
+
+const navigate = async (path: string): Promise<void> => {
+	window.history.pushState({}, "", path);
+	window.dispatchEvent(new PopStateEvent("popstate"));
+};
+
+const click = async (selector: string): Promise<void> => {
+	const element = document.querySelector(selector);
+	if (!element) {
+		throw new Error(`Element not found: ${selector}`);
+	}
+	(element as HTMLElement).click();
+};
+
+const fill = async (selector: string, value: string): Promise<void> => {
+	const element = document.querySelector(selector) as HTMLInputElement;
+	if (!element) {
+		throw new Error(`Element not found: ${selector}`);
+	}
+	element.value = value;
+	element.dispatchEvent(new Event("input", { bubbles: true }));
+};
+
+const wait = async (timeout: number): Promise<void> => {
+	return new Promise((resolve) => setTimeout(resolve, timeout));
+};
+
+const assert = async (assertion: string): Promise<void> => {
+	if (!assertion) {
+		throw new Error("Assertion is empty");
+	}
+};
+
+export const getTestStatistics = (
+	results: readonly E2ETestResult[],
+): {
+	readonly total: number;
+	readonly passed: number;
+	readonly failed: number;
+	readonly passRate: number;
+	readonly averageDuration: number;
+} => {
+	const total = results.length;
+	const passed = results.filter((r) => r.success).length;
+	const failed = total - passed;
+	const passRate = total > 0 ? (passed / total) * 100 : 0;
+	const averageDuration =
+		total > 0 ? results.reduce((sum, r) => sum + r.duration, 0) / total : 0;
+
+	return {
+		total,
+		passed,
+		failed,
+		passRate,
+		averageDuration,
+	};
+};
+
+export const generateTestReport = (
+	results: readonly E2ETestResult[],
+): string => {
+	const stats = getTestStatistics(results);
+	let report = "E2E Test Report\n";
+	report += "================\n\n";
+	report += `Total Tests: ${stats.total}\n`;
+	report += `Passed: ${stats.passed}\n`;
+	report += `Failed: ${stats.failed}\n`;
+	report += `Pass Rate: ${stats.passRate.toFixed(2)}%\n`;
+	report += `Average Duration: ${stats.averageDuration.toFixed(2)}ms\n\n`;
+
+	for (const result of results) {
+		report += `Test: ${result.testName}\n`;
+		report += `Status: ${result.success ? "PASSED" : "FAILED"}\n`;
+		report += `Duration: ${result.duration}ms\n`;
+		if (result.error) {
+			report += `Error: ${result.error}\n`;
+		}
+		report += "\n";
+	}
+
+	return report;
+};

package/src/router/modules/route-testing/domain/operations/index.ts

@@ -0,0 +1,3 @@
+export * from "./contract-testing-operations";
+export * from "./e2e-testing-operations";
+export * from "./route-testing-core";

package/src/router/modules/route-testing/domain/operations/route-testing-core.ts

@@ -0,0 +1,48 @@
+import type { RouteMatch, RouteParams } from "../../../../shared/types";
+import { failure, type Result, success } from "../../../../shared/types";
+import type { TestingState } from "../models";
+
+export const testRouteMatch = (
+	state: TestingState,
+	path: string,
+): Result<RouteMatch> => {
+	const route = state.routes.find((r) => {
+		const regex = new RegExp(`^${r.path.replace(/:([^/]+)/g, "([^/]+)")}$`);
+		return regex.test(path);
+	});
+
+	if (!route) {
+		return failure(new Error(`No route found for path: ${path}`));
+	}
+
+	const params = extractParams(route.path, path);
+	return success({
+		path,
+		params,
+		searchParams: Object.freeze({}),
+	});
+};
+
+export const testAllRoutes = (
+	state: TestingState,
+): Result<{ readonly path: string }[]> => {
+	const testRoutes = state.routes.map((route) => ({
+		path: route.path,
+	}));
+	return success(testRoutes);
+};
+
+const extractParams = (routePath: string, actualPath: string): RouteParams => {
+	const params: RouteParams = {};
+	const routeParts = routePath.split("/");
+	const actualParts = actualPath.split("/");
+
+	for (let i = 0; i < routeParts.length; i++) {
+		if (routeParts[i].startsWith(":")) {
+			const paramName = routeParts[i].slice(1);
+			params[paramName] = actualParts[i];
+		}
+	}
+
+	return Object.freeze(params);
+};

package/src/router/modules/route-testing/domain/validators/index.ts

@@ -0,0 +1,34 @@
+import type { E2ETest, E2ETestStep, ParamSchema } from "../models";
+
+export const validateParamSchema = (schema: ParamSchema): boolean => {
+	const validTypes = ["string", "number", "boolean", "uuid", "email"];
+	if (!validTypes.includes(schema.type)) return false;
+	if (typeof schema.required !== "boolean") return false;
+	if (schema.pattern && !(schema.pattern instanceof RegExp)) return false;
+	if (schema.enum && !Array.isArray(schema.enum)) return false;
+	return true;
+};
+
+export const validateTestStep = (step: E2ETestStep): boolean => {
+	const validActions = ["navigate", "click", "fill", "wait", "assert"];
+	if (!validActions.includes(step.action)) return false;
+	if (step.action === "navigate" && !step.value) return false;
+	if (step.action === "click" && !step.selector) return false;
+	if (step.action === "fill" && (!step.selector || !step.value)) return false;
+	if (step.action === "assert" && !step.assertion) return false;
+	return true;
+};
+
+export const validateE2ETest = (test: E2ETest): boolean => {
+	if (!test.name || typeof test.name !== "string") return false;
+	if (!test.route || typeof test.route !== "string") return false;
+	if (!Array.isArray(test.steps) || test.steps.length === 0) return false;
+	if (!test.steps.every(validateTestStep)) return false;
+	return true;
+};
+
+export const validateRoutePath = (path: string): boolean => {
+	if (!path || typeof path !== "string") return false;
+	if (!path.startsWith("/")) return false;
+	return true;
+};