@rog0x/mcp-testing-tools 1.0.0

package/src/tools/assertion-helper.ts

@@ -0,0 +1,273 @@
+/**
+ * Given expected vs actual values, generate detailed assertion code
+ * with descriptive messages. Supports deep object comparison,
+ * array comparison, and type checking.
+ */
+
+interface AssertionOptions {
+  expected: string;
+  actual: string;
+  label?: string;
+  framework?: "jest" | "vitest" | "chai";
+  deep?: boolean;
+}
+
+interface DiffEntry {
+  path: string;
+  expected: unknown;
+  actual: unknown;
+  type: "missing" | "extra" | "type_mismatch" | "value_mismatch";
+}
+
+function safeJsonParse(value: string): { parsed: unknown; isJson: boolean } {
+  try {
+    const parsed = JSON.parse(value);
+    return { parsed, isJson: true };
+  } catch {
+    return { parsed: value, isJson: false };
+  }
+}
+
+function typeOf(value: unknown): string {
+  if (value === null) return "null";
+  if (value === undefined) return "undefined";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+function deepDiff(expected: unknown, actual: unknown, path: string = "$"): DiffEntry[] {
+  const diffs: DiffEntry[] = [];
+  const expType = typeOf(expected);
+  const actType = typeOf(actual);
+
+  if (expType !== actType) {
+    diffs.push({ path, expected, actual, type: "type_mismatch" });
+    return diffs;
+  }
+
+  if (expType === "array" && actType === "array") {
+    const expArr = expected as unknown[];
+    const actArr = actual as unknown[];
+    const maxLen = Math.max(expArr.length, actArr.length);
+    if (expArr.length !== actArr.length) {
+      diffs.push({
+        path: `${path}.length`,
+        expected: expArr.length,
+        actual: actArr.length,
+        type: "value_mismatch",
+      });
+    }
+    for (let i = 0; i < maxLen; i++) {
+      if (i >= expArr.length) {
+        diffs.push({ path: `${path}[${i}]`, expected: undefined, actual: actArr[i], type: "extra" });
+      } else if (i >= actArr.length) {
+        diffs.push({ path: `${path}[${i}]`, expected: expArr[i], actual: undefined, type: "missing" });
+      } else {
+        diffs.push(...deepDiff(expArr[i], actArr[i], `${path}[${i}]`));
+      }
+    }
+    return diffs;
+  }
+
+  if (expType === "object" && actType === "object" && expected !== null && actual !== null) {
+    const expObj = expected as Record<string, unknown>;
+    const actObj = actual as Record<string, unknown>;
+    const allKeys = new Set([...Object.keys(expObj), ...Object.keys(actObj)]);
+
+    for (const key of allKeys) {
+      const childPath = `${path}.${key}`;
+      if (!(key in expObj)) {
+        diffs.push({ path: childPath, expected: undefined, actual: actObj[key], type: "extra" });
+      } else if (!(key in actObj)) {
+        diffs.push({ path: childPath, expected: expObj[key], actual: undefined, type: "missing" });
+      } else {
+        diffs.push(...deepDiff(expObj[key], actObj[key], childPath));
+      }
+    }
+    return diffs;
+  }
+
+  if (expected !== actual) {
+    diffs.push({ path, expected, actual, type: "value_mismatch" });
+  }
+
+  return diffs;
+}
+
+function formatValue(value: unknown): string {
+  if (value === undefined) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "object") return JSON.stringify(value, null, 2);
+  return String(value);
+}
+
+function generateJestAssertions(
+  expected: unknown,
+  actual: unknown,
+  expectedExpr: string,
+  actualExpr: string,
+  label: string,
+  diffs: DiffEntry[],
+  deep: boolean
+): string {
+  const lines: string[] = [];
+  const expType = typeOf(expected);
+  const actType = typeOf(actual);
+
+  lines.push(`// Assertions for: ${label}`);
+  lines.push(`const expected = ${formatValue(expected)};`);
+  lines.push(`const actual = ${formatValue(actual)};`);
+  lines.push("");
+
+  // Type check
+  lines.push(`// Type check`);
+  lines.push(`expect(typeof actual).toBe(${JSON.stringify(actType === "array" ? "object" : actType)});`);
+
+  if (expType === "array" && actType === "array") {
+    lines.push(`expect(Array.isArray(actual)).toBe(true);`);
+  }
+
+  if (diffs.length === 0) {
+    lines.push("");
+    lines.push("// Values match");
+    if (deep && (expType === "object" || expType === "array")) {
+      lines.push(`expect(actual).toEqual(expected);`);
+    } else {
+      lines.push(`expect(actual).toBe(expected);`);
+    }
+  } else {
+    lines.push("");
+    lines.push(`// ${diffs.length} difference(s) found:`);
+
+    for (const diff of diffs) {
+      lines.push("");
+      switch (diff.type) {
+        case "type_mismatch":
+          lines.push(`// Type mismatch at ${diff.path}`);
+          lines.push(`// Expected type: ${typeOf(diff.expected)}, Actual type: ${typeOf(diff.actual)}`);
+          lines.push(`expect(typeof ${pathToAccessor(diff.path, "actual")}).toBe(${JSON.stringify(typeOf(diff.expected))});`);
+          break;
+        case "value_mismatch":
+          lines.push(`// Value mismatch at ${diff.path}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).toBe(${formatValue(diff.expected)});`);
+          lines.push(`// Actual value: ${formatValue(diff.actual)}`);
+          break;
+        case "missing":
+          lines.push(`// Missing at ${diff.path}`);
+          lines.push(`// Expected: ${formatValue(diff.expected)}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).toBeDefined();`);
+          break;
+        case "extra":
+          lines.push(`// Unexpected property at ${diff.path}`);
+          lines.push(`// Actual value: ${formatValue(diff.actual)}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).toBeUndefined();`);
+          break;
+      }
+    }
+
+    lines.push("");
+    lines.push("// Full deep equality (will fail if differences exist)");
+    if (deep && (expType === "object" || expType === "array")) {
+      lines.push(`expect(actual).toEqual(expected);`);
+    } else {
+      lines.push(`expect(actual).toBe(expected);`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function generateChaiAssertions(
+  expected: unknown,
+  actual: unknown,
+  label: string,
+  diffs: DiffEntry[],
+  deep: boolean
+): string {
+  const lines: string[] = [];
+  const expType = typeOf(expected);
+
+  lines.push(`// Assertions for: ${label}`);
+  lines.push(`const expected = ${formatValue(expected)};`);
+  lines.push(`const actual = ${formatValue(actual)};`);
+  lines.push("");
+
+  if (diffs.length === 0) {
+    lines.push("// Values match");
+    if (deep && (expType === "object" || expType === "array")) {
+      lines.push(`expect(actual).to.deep.equal(expected);`);
+    } else {
+      lines.push(`expect(actual).to.equal(expected);`);
+    }
+  } else {
+    lines.push(`// ${diffs.length} difference(s) found:`);
+    for (const diff of diffs) {
+      lines.push("");
+      switch (diff.type) {
+        case "type_mismatch":
+          lines.push(`// Type mismatch at ${diff.path}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).to.be.a(${JSON.stringify(typeOf(diff.expected))});`);
+          break;
+        case "value_mismatch":
+          lines.push(`// Value mismatch at ${diff.path}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).to.equal(${formatValue(diff.expected)});`);
+          break;
+        case "missing":
+          lines.push(`// Missing at ${diff.path}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).to.exist;`);
+          break;
+        case "extra":
+          lines.push(`// Unexpected at ${diff.path}`);
+          lines.push(`expect(${pathToAccessor(diff.path, "actual")}).to.not.exist;`);
+          break;
+      }
+    }
+    lines.push("");
+    lines.push("// Full equality");
+    lines.push(`expect(actual).to.deep.equal(expected);`);
+  }
+
+  return lines.join("\n");
+}
+
+function pathToAccessor(path: string, varName: string): string {
+  if (path === "$") return varName;
+  // Convert $.foo[0].bar to varName.foo[0].bar
+  return varName + path.slice(1);
+}
+
+export function generateAssertions(options: AssertionOptions): {
+  code: string;
+  diffs: DiffEntry[];
+  summary: string;
+} {
+  const {
+    expected: expectedStr,
+    actual: actualStr,
+    label = "value comparison",
+    framework = "jest",
+    deep = true,
+  } = options;
+
+  const { parsed: expected } = safeJsonParse(expectedStr);
+  const { parsed: actual } = safeJsonParse(actualStr);
+
+  const diffs = deepDiff(expected, actual);
+
+  let code: string;
+
+  if (framework === "chai") {
+    code = generateChaiAssertions(expected, actual, label, diffs, deep);
+  } else {
+    // jest and vitest use the same API
+    code = generateJestAssertions(expected, actual, "expected", "actual", label, diffs, deep);
+  }
+
+  const summary =
+    diffs.length === 0
+      ? "Values are identical. All assertions will pass."
+      : `Found ${diffs.length} difference(s): ${diffs.map((d) => `${d.type} at ${d.path}`).join(", ")}`;
+
+  return { code, diffs, summary };
+}

package/src/tools/mock-data.ts

@@ -0,0 +1,241 @@
+/**
+ * Generate realistic mock data: names, emails, addresses, dates, UUIDs,
+ * phone numbers, company names, credit card numbers (fake), IP addresses.
+ * Configurable count and locale.
+ */
+
+interface MockDataOptions {
+  type: string;
+  count: number;
+  locale: string;
+}
+
+// Seeded pseudo-random for deterministic output within a call
+class SeededRandom {
+  private state: number;
+  constructor(seed: number) {
+    this.state = seed;
+  }
+  next(): number {
+    this.state = (this.state * 1664525 + 1013904223) & 0x7fffffff;
+    return this.state / 0x7fffffff;
+  }
+  int(min: number, max: number): number {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  pick<T>(arr: readonly T[]): T {
+    return arr[this.int(0, arr.length - 1)];
+  }
+}
+
+const FIRST_NAMES_EN = [
+  "James", "Mary", "Robert", "Patricia", "John", "Jennifer", "Michael", "Linda",
+  "David", "Elizabeth", "William", "Barbara", "Richard", "Susan", "Joseph", "Jessica",
+  "Thomas", "Sarah", "Christopher", "Karen", "Charles", "Lisa", "Daniel", "Nancy",
+  "Matthew", "Betty", "Anthony", "Margaret", "Mark", "Sandra", "Steven", "Ashley",
+] as const;
+
+const FIRST_NAMES_ES = [
+  "Carlos", "Maria", "Jose", "Ana", "Luis", "Carmen", "Miguel", "Laura",
+  "Juan", "Isabel", "Pedro", "Rosa", "Diego", "Elena", "Pablo", "Sofia",
+] as const;
+
+const LAST_NAMES_EN = [
+  "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
+  "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson",
+  "Thomas", "Taylor", "Moore", "Jackson", "Martin", "Lee", "Thompson", "White",
+] as const;
+
+const LAST_NAMES_ES = [
+  "Garcia", "Rodriguez", "Martinez", "Lopez", "Gonzalez", "Hernandez", "Perez",
+  "Sanchez", "Ramirez", "Torres", "Flores", "Rivera", "Gomez", "Diaz",
+] as const;
+
+const STREET_NAMES = [
+  "Main St", "Oak Ave", "Cedar Ln", "Elm St", "Pine Rd", "Maple Dr",
+  "Washington Blvd", "Park Ave", "Lake Dr", "River Rd", "Hill St", "Forest Way",
+  "Sunset Blvd", "Highland Ave", "Valley Rd", "Spring St", "Meadow Ln",
+] as const;
+
+const CITIES_EN = [
+  "New York", "Los Angeles", "Chicago", "Houston", "Phoenix", "Philadelphia",
+  "San Antonio", "San Diego", "Dallas", "Austin", "Portland", "Denver",
+  "Seattle", "Boston", "Nashville", "Atlanta", "Miami", "Minneapolis",
+] as const;
+
+const CITIES_ES = [
+  "Madrid", "Barcelona", "Valencia", "Sevilla", "Bilbao", "Malaga",
+  "Zaragoza", "Alicante", "Cordoba", "Granada", "Murcia", "Palma",
+] as const;
+
+const STATES = ["CA", "TX", "NY", "FL", "IL", "PA", "OH", "GA", "NC", "MI", "WA", "OR", "CO", "AZ"] as const;
+
+const DOMAINS = ["example.com", "testmail.org", "mockdata.net", "sampledomain.io", "fakeinbox.dev"] as const;
+
+const COMPANY_SUFFIXES = ["Inc", "LLC", "Corp", "Group", "Solutions", "Technologies", "Systems", "Labs", "Ventures", "Partners"] as const;
+
+const COMPANY_WORDS = [
+  "Apex", "Horizon", "Vertex", "Pinnacle", "Atlas", "Nova", "Stellar",
+  "Crimson", "Azure", "Cobalt", "Onyx", "Prism", "Quantum", "Vector",
+  "Zenith", "Fusion", "Nexus", "Summit", "Cipher", "Vanguard",
+] as const;
+
+const TLD_BY_LOCALE: Record<string, string[]> = {
+  en: [".com", ".org", ".net", ".io"],
+  es: [".es", ".com", ".org"],
+};
+
+function getFirstNames(locale: string): readonly string[] {
+  return locale === "es" ? FIRST_NAMES_ES : FIRST_NAMES_EN;
+}
+function getLastNames(locale: string): readonly string[] {
+  return locale === "es" ? LAST_NAMES_ES : LAST_NAMES_EN;
+}
+function getCities(locale: string): readonly string[] {
+  return locale === "es" ? CITIES_ES : CITIES_EN;
+}
+
+function generateName(rng: SeededRandom, locale: string): string {
+  return `${rng.pick(getFirstNames(locale))} ${rng.pick(getLastNames(locale))}`;
+}
+
+function generateEmail(rng: SeededRandom, locale: string): string {
+  const first = rng.pick(getFirstNames(locale)).toLowerCase();
+  const last = rng.pick(getLastNames(locale)).toLowerCase();
+  const sep = rng.pick([".", "_", ""]);
+  const num = rng.int(1, 999);
+  const domain = rng.pick(DOMAINS);
+  return `${first}${sep}${last}${num}@${domain}`;
+}
+
+function generateAddress(rng: SeededRandom, locale: string): string {
+  const num = rng.int(100, 9999);
+  const street = rng.pick(STREET_NAMES);
+  const city = rng.pick(getCities(locale));
+  const state = rng.pick(STATES);
+  const zip = String(rng.int(10000, 99999));
+  return `${num} ${street}, ${city}, ${state} ${zip}`;
+}
+
+function generateDate(rng: SeededRandom): string {
+  const year = rng.int(1970, 2030);
+  const month = String(rng.int(1, 12)).padStart(2, "0");
+  const day = String(rng.int(1, 28)).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function generateUUID(rng: SeededRandom): string {
+  const hex = () => rng.int(0, 15).toString(16);
+  const seg = (len: number) => Array.from({ length: len }, hex).join("");
+  return `${seg(8)}-${seg(4)}-4${seg(3)}-${rng.pick(["8", "9", "a", "b"])}${seg(3)}-${seg(12)}`;
+}
+
+function generatePhone(rng: SeededRandom, locale: string): string {
+  if (locale === "es") {
+    return `+34 ${rng.int(600, 699)} ${rng.int(100, 999)} ${rng.int(100, 999)}`;
+  }
+  const area = rng.int(200, 999);
+  const mid = rng.int(200, 999);
+  const last = rng.int(1000, 9999);
+  return `+1 (${area}) ${mid}-${last}`;
+}
+
+function generateCompanyName(rng: SeededRandom): string {
+  const numWords = rng.int(1, 2);
+  const words = Array.from({ length: numWords }, () => rng.pick(COMPANY_WORDS));
+  return `${words.join(" ")} ${rng.pick(COMPANY_SUFFIXES)}`;
+}
+
+function generateCreditCard(rng: SeededRandom): string {
+  // Fake Visa-like number starting with 4, fails Luhn check intentionally
+  const groups = [
+    `4${rng.int(100, 999)}`,
+    String(rng.int(1000, 9999)),
+    String(rng.int(1000, 9999)),
+    String(rng.int(1000, 9999)),
+  ];
+  return groups.join(" ");
+}
+
+function generateIP(rng: SeededRandom): string {
+  return `${rng.int(1, 254)}.${rng.int(0, 255)}.${rng.int(0, 255)}.${rng.int(1, 254)}`;
+}
+
+type GeneratorFn = (rng: SeededRandom, locale: string) => string;
+
+const GENERATORS: Record<string, GeneratorFn> = {
+  name: generateName,
+  email: generateEmail,
+  address: generateAddress,
+  date: generateDate,
+  uuid: (rng) => generateUUID(rng),
+  phone: generatePhone,
+  company: (rng) => generateCompanyName(rng),
+  credit_card: (rng) => generateCreditCard(rng),
+  ip: (rng) => generateIP(rng),
+};
+
+const SUPPORTED_TYPES = Object.keys(GENERATORS);
+
+export function generateMockData(type: string, count: number = 10, locale: string = "en"): {
+  type: string;
+  locale: string;
+  count: number;
+  data: string[];
+  supportedTypes: string[];
+} {
+  const normalizedType = type.toLowerCase().replace(/[\s-]/g, "_");
+
+  if (!GENERATORS[normalizedType]) {
+    return {
+      type: normalizedType,
+      locale,
+      count: 0,
+      data: [],
+      supportedTypes: SUPPORTED_TYPES,
+    };
+  }
+
+  const safeCount = Math.min(Math.max(1, count), 1000);
+  const rng = new SeededRandom(Date.now() % 100000);
+  const generator = GENERATORS[normalizedType];
+  const data: string[] = [];
+
+  for (let i = 0; i < safeCount; i++) {
+    data.push(generator(rng, locale));
+  }
+
+  return {
+    type: normalizedType,
+    locale,
+    count: safeCount,
+    data,
+    supportedTypes: SUPPORTED_TYPES,
+  };
+}
+
+export function generateMixedMockData(
+  types: string[],
+  count: number = 5,
+  locale: string = "en"
+): Record<string, string>[] {
+  const safeCount = Math.min(Math.max(1, count), 1000);
+  const rng = new SeededRandom(Date.now() % 100000);
+  const validTypes = types
+    .map((t) => t.toLowerCase().replace(/[\s-]/g, "_"))
+    .filter((t) => GENERATORS[t]);
+
+  if (validTypes.length === 0) {
+    return [];
+  }
+
+  const records: Record<string, string>[] = [];
+  for (let i = 0; i < safeCount; i++) {
+    const record: Record<string, string> = {};
+    for (const t of validTypes) {
+      record[t] = GENERATORS[t](rng, locale);
+    }
+    records.push(record);
+  }
+  return records;
+}