@schmock/faker 2.0.0 → 2.0.2

package/src/overrides.property.test.ts

@@ -0,0 +1,172 @@
+import fc from "fast-check";
+import { describe, expect, it } from "vitest";
+import { applyOverrides, determineArrayCount } from "./overrides";
+
+describe("applyOverrides — property-based tests", () => {
+  it("never adds keys not in data or overrides (shape preservation)", () => {
+    // Use simple alphanumeric keys to avoid dot-path splitting edge cases,
+    // since keys containing "." are treated as nested paths by applyOverrides.
+    const safeKey = fc.stringMatching(/^[a-z][a-zA-Z0-9]{0,9}$/);
+
+    fc.assert(
+      fc.property(
+        fc.dictionary(safeKey, fc.jsonValue()),
+        fc.dictionary(safeKey, fc.jsonValue()),
+        (data, overrides) => {
+          const result = applyOverrides(data, overrides) as Record<
+            string,
+            unknown
+          >;
+
+          const allowedKeys = new Set([
+            ...Object.keys(data),
+            ...Object.keys(overrides),
+          ]);
+          for (const key of Object.keys(result)) {
+            expect(allowedKeys.has(key)).toBe(true);
+          }
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+
+  it("with empty overrides returns structuredClone of data", () => {
+    fc.assert(
+      fc.property(fc.dictionary(fc.string(), fc.jsonValue()), (data) => {
+        const result = applyOverrides(data, {});
+
+        // Should be deep-equal but not the same reference
+        expect(result).toEqual(data);
+        if (Object.keys(data).length > 0) {
+          expect(result).not.toBe(data);
+        }
+      }),
+      { numRuns: 100 },
+    );
+  });
+
+  it("processTemplate idempotency: processing an already-resolved template is a no-op", () => {
+    // Resolved values contain no {{ }} markers, so re-applying overrides
+    // with the same non-template values should be idempotent
+    fc.assert(
+      fc.property(
+        fc.record({
+          name: fc.string().filter((s) => !s.includes("{{")),
+          age: fc.integer({ min: 0, max: 200 }),
+        }),
+        (data) => {
+          const overrides = { name: "Alice", age: 42 };
+
+          const first = applyOverrides(data, overrides);
+          const second = applyOverrides(
+            first as Record<string, unknown>,
+            overrides,
+          );
+
+          expect(second).toEqual(first);
+        },
+      ),
+      { numRuns: 100 },
+    );
+  });
+
+  it("DANGEROUS_KEYS (__proto__, constructor, prototype) are always rejected in setNestedProperty", () => {
+    const dangerousKeys = ["__proto__", "constructor", "prototype"];
+
+    for (const dangerous of dangerousKeys) {
+      // Flat key — dangerous key is skipped entirely, so no own property is set
+      const flatResult = applyOverrides(
+        { safe: "value" },
+        { [dangerous]: "injected" },
+      ) as Record<string, unknown>;
+      expect(Object.hasOwn(flatResult, dangerous)).toBe(false);
+
+      // Nested path with dangerous key at start — entire path is skipped
+      const nestedStartResult = applyOverrides(
+        { safe: "value" },
+        { [`${dangerous}.nested`]: "injected" },
+      ) as Record<string, unknown>;
+      expect(Object.hasOwn(nestedStartResult, dangerous)).toBe(false);
+
+      // Nested path with dangerous key in middle — traversal aborts
+      const nestedMiddleResult = applyOverrides(
+        { a: { b: "original" } },
+        { [`a.${dangerous}.c`]: "injected" },
+      ) as Record<string, unknown>;
+      const inner = nestedMiddleResult.a as Record<string, unknown>;
+      expect(Object.hasOwn(inner, dangerous)).toBe(false);
+
+      // Nested path with dangerous key at end — final key set is blocked
+      const nestedEndResult = applyOverrides(
+        { a: { b: "original" } },
+        { [`a.${dangerous}`]: "injected" },
+      ) as Record<string, unknown>;
+      const innerEnd = nestedEndResult.a as Record<string, unknown>;
+      expect(Object.hasOwn(innerEnd, dangerous)).toBe(false);
+    }
+  });
+});
+
+describe("applyOverrides — edge cases", () => {
+  it("deeply nested path 'a.b.c.d.e' creates intermediate objects", () => {
+    const data = { existing: "value" };
+    const result = applyOverrides(data, {
+      "a.b.c.d.e": "deep",
+    }) as Record<string, unknown>;
+
+    expect(result.existing).toBe("value");
+    const a = result.a as Record<string, unknown>;
+    const b = a.b as Record<string, unknown>;
+    const c = b.c as Record<string, unknown>;
+    const d = c.d as Record<string, unknown>;
+    expect(d.e).toBe("deep");
+  });
+
+  it("template '{{params.id}}' resolves correctly", () => {
+    const data = { userId: "placeholder" };
+    const result = applyOverrides(
+      data,
+      { userId: "{{params.id}}" },
+      { id: "abc-123" },
+    ) as Record<string, unknown>;
+
+    expect(result.userId).toBe("abc-123");
+  });
+
+  it("mixed template 'Hello {{params.name}}!' resolves to string", () => {
+    const data = { greeting: "placeholder" };
+    const result = applyOverrides(
+      data,
+      { greeting: "Hello {{params.name}}!" },
+      { name: "World" },
+    ) as Record<string, unknown>;
+
+    expect(result.greeting).toBe("Hello World!");
+    expect(typeof result.greeting).toBe("string");
+  });
+
+  it("on non-object data (null) returns data unchanged", () => {
+    expect(applyOverrides(null, { key: "value" })).toBe(null);
+  });
+
+  it("on non-object data (string) returns data unchanged", () => {
+    expect(applyOverrides("hello", { key: "value" })).toBe("hello");
+  });
+
+  it("on non-object data (number) returns data unchanged", () => {
+    expect(applyOverrides(42, { key: "value" })).toBe(42);
+  });
+});
+
+describe("determineArrayCount — edge cases", () => {
+  it("with explicitCount=0 returns 0", () => {
+    expect(determineArrayCount({}, 0)).toBe(0);
+  });
+
+  it("with negative explicitCount returns 0", () => {
+    expect(determineArrayCount({}, -1)).toBe(0);
+    expect(determineArrayCount({}, -100)).toBe(0);
+    expect(determineArrayCount({}, Number.NEGATIVE_INFINITY)).toBe(0);
+  });
+});

package/src/overrides.test.ts

@@ -0,0 +1,38 @@
+import type { JSONSchema7 } from "json-schema";
+import { describe, expect, it } from "vitest";
+import { determineArrayCount } from "./overrides";
+
+describe("determineArrayCount", () => {
+  it("returns explicit count when provided", () => {
+    expect(determineArrayCount({}, 5)).toBe(5);
+  });
+
+  it("returns 0 for negative explicit count", () => {
+    expect(determineArrayCount({}, -3)).toBe(0);
+  });
+
+  it("returns value within minItems/maxItems range", () => {
+    const schema: JSONSchema7 = { minItems: 2, maxItems: 5 };
+    for (let i = 0; i < 50; i++) {
+      const count = determineArrayCount(schema);
+      expect(count).toBeGreaterThanOrEqual(2);
+      expect(count).toBeLessThanOrEqual(5);
+    }
+  });
+
+  it("handles minItems greater than maxItems without producing garbage", () => {
+    const schema: JSONSchema7 = { minItems: 10, maxItems: 3 };
+    const count = determineArrayCount(schema);
+
+    // Should not produce negative numbers or unreasonably large values
+    expect(count).toBeGreaterThanOrEqual(0);
+    expect(Number.isFinite(count)).toBe(true);
+    expect(Number.isNaN(count)).toBe(false);
+  });
+
+  it("handles minItems equal to maxItems", () => {
+    const schema: JSONSchema7 = { minItems: 5, maxItems: 5 };
+    const count = determineArrayCount(schema);
+    expect(count).toBe(5);
+  });
+});

package/src/overrides.ts

@@ -24,10 +24,9 @@ export function determineArrayCount(
   }
 
   if (schema.minItems !== undefined && schema.maxItems !== undefined) {
-    return (
-      Math.floor(random() * (schema.maxItems - schema.minItems + 1)) +
-      schema.minItems
-    );
+    const min = schema.minItems;
+    const max = Math.max(min, schema.maxItems);
+    return Math.floor(random() * (max - min + 1)) + min;
   }
 
   if (schema.minItems !== undefined) {
@@ -52,15 +51,16 @@ export function determineArrayCount(
  * @returns Data with overrides applied
  */
 export function applyOverrides(
-  data: any,
-  overrides?: Record<string, any>,
+  data: unknown,
+  overrides?: Record<string, unknown>,
   params?: Record<string, string>,
-  state?: any,
+  state?: Record<string, unknown>,
   query?: Record<string, string>,
-): any {
+): unknown {
   if (!overrides) return data;
+  if (typeof data !== "object" || data === null) return data;
 
-  const result = structuredClone(data);
+  const result = structuredClone(data) as Record<string, unknown>;
 
   for (const [key, value] of Object.entries(overrides)) {
     if (DANGEROUS_KEYS.has(key)) continue;
@@ -74,17 +74,18 @@ export function applyOverrides(
         value !== null &&
         !Array.isArray(value)
       ) {
+        const nested = value as Record<string, unknown>;
         // Recursively apply nested overrides
         if (result[key] && typeof result[key] === "object") {
           result[key] = applyOverrides(
             result[key],
-            value,
+            nested,
             params,
             state,
             query,
           );
         } else {
-          result[key] = applyOverrides({}, value, params, state, query);
+          result[key] = applyOverrides({}, nested, params, state, query);
         }
       } else if (typeof value === "string" && value.includes("{{")) {
         // Template processing
@@ -99,17 +100,13 @@ export function applyOverrides(
 }
 
 function setNestedProperty(
-  obj: any,
+  obj: Record<string, unknown>,
   path: string,
-  value: any,
-  context: {
-    params?: Record<string, string>;
-    state?: any;
-    query?: Record<string, string>;
-  },
+  value: unknown,
+  context: TemplateContext,
 ): void {
   const parts = path.split(".");
-  let current = obj;
+  let current: Record<string, unknown> = obj;
 
   // Navigate to the parent of the target property
   for (let i = 0; i < parts.length - 1; i++) {
@@ -122,7 +119,7 @@ function setNestedProperty(
     ) {
       current[part] = {};
     }
-    current = current[part];
+    current = current[part] as Record<string, unknown>;
   }
 
   // Set the final property
@@ -135,51 +132,45 @@ function setNestedProperty(
   }
 }
 
-function processTemplate(
-  template: string,
-  context: {
-    params?: Record<string, string>;
-    state?: any;
-    query?: Record<string, string>;
-  },
-): any {
+interface TemplateContext {
+  params?: Record<string, string>;
+  state?: Record<string, unknown>;
+  query?: Record<string, string>;
+}
+
+function resolveTemplatePath(
+  context: TemplateContext,
+  expression: string,
+): unknown {
+  const parts = expression.trim().split(".");
+  let result: unknown = context;
+
+  for (const part of parts) {
+    if (result && typeof result === "object") {
+      result = (result as Record<string, unknown>)[part];
+    } else {
+      return undefined;
+    }
+  }
+
+  return result;
+}
+
+function processTemplate(template: string, context: TemplateContext): unknown {
   // Check if the template is just a single template expression
   const singleTemplateMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
   if (singleTemplateMatch) {
     // For single templates, return the actual value without string conversion
-    const expression = singleTemplateMatch[1];
-    const parts = expression.trim().split(".");
-    let result: any = context;
-
-    for (const part of parts) {
-      if (result && typeof result === "object") {
-        result = result[part];
-      } else {
-        return template; // Return original if can't resolve
-      }
-    }
-
+    const result = resolveTemplatePath(context, singleTemplateMatch[1]);
     return result !== undefined ? result : template;
   }
 
   // For templates mixed with other text, do string replacement
-  const processed = template.replace(
+  return template.replace(
     /\{\{\s*([^}]+)\s*\}\}/g,
-    (match, expression) => {
-      const parts = expression.trim().split(".");
-      let result: any = context;
-
-      for (const part of parts) {
-        if (result && typeof result === "object") {
-          result = result[part];
-        } else {
-          return match; // Return original if can't resolve
-        }
-      }
-
+    (match, expression: string) => {
+      const result = resolveTemplatePath(context, expression);
       return result !== undefined ? String(result) : match;
     },
   );
-
-  return processed;
 }

package/src/plugin-integration.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import { version as packageVersion } from "../package.json";
 import { fakerPlugin } from "./index";
 import { schemas, validators } from "./test-utils";
 
@@ -11,7 +12,7 @@ describe("Schema Plugin Integration", () => {
       });
       expect(validPlugin).toBeDefined();
       expect(validPlugin.name).toBe("faker");
-      expect(validPlugin.version).toBe("1.0.1");
+      expect(validPlugin.version).toBe(packageVersion);
 
       // Invalid schema should throw immediately
       expect(() => {

package/src/post-process.test.ts

@@ -0,0 +1,152 @@
+import type { JSONSchema7 } from "json-schema";
+import { describe, expect, it } from "vitest";
+import { NULLABLE_NULL_PROBABILITY } from "./constants";
+import { generateFromSchema } from "./index";
+
+/**
+ * Tests for postProcessGenerated behavior.
+ * Since postProcessGenerated is not exported, we test it indirectly via generateFromSchema.
+ */
+
+describe("postProcessGenerated — schmockNullable", () => {
+  it("schema with schmockNullable: true — over 100 runs, some should be null", async () => {
+    // We use a schema where the field has schmockNullable set.
+    // Since enhanceSchemaWithSmartMapping may add this marker for nullable fields,
+    // we test by adding the marker directly through a schema that triggers it.
+    // The simplest approach: craft a schema with the x-nullable pattern that
+    // enhanceSchemaWithSmartMapping would process, or use a type that gets
+    // the schmockNullable marker applied.
+    //
+    // Since schmockNullable is set by the enhancement layer for nullable fields,
+    // we test via a schema with nullable: true (OpenAPI pattern) or anyOf with null.
+    // However, the safest approach is to test a field that we know goes through
+    // postProcessGenerated with the schmockNullable flag.
+
+    // Direct approach: construct a schema that includes schmockNullable at the property level
+    const schema: JSONSchema7 & Record<string, unknown> = {
+      type: "object",
+      properties: {
+        value: {
+          type: "string",
+          schmockNullable: true,
+        } as JSONSchema7 & { schmockNullable: boolean },
+      },
+      required: ["value"],
+    };
+
+    let nullCount = 0;
+    const runs = 200;
+    for (let i = 0; i < runs; i++) {
+      const result = (await generateFromSchema({ schema })) as Record<
+        string,
+        unknown
+      >;
+      if (result.value === null) {
+        nullCount++;
+      }
+    }
+
+    // With NULLABLE_NULL_PROBABILITY = 0.05, over 200 runs we expect ~10 nulls.
+    // We use a loose check: at least 1 null (very unlikely to get 0 in 200 trials at 5%)
+    expect(nullCount).toBeGreaterThan(0);
+    // And not all nulls
+    expect(nullCount).toBeLessThan(runs);
+  });
+});
+
+describe("postProcessGenerated — schmockTrueProbability", () => {
+  it("schema with schmockTrueProbability: 0.8 — over 100 runs, ~80% should be true", async () => {
+    const schema: JSONSchema7 & Record<string, unknown> = {
+      type: "object",
+      properties: {
+        isActive: {
+          type: "boolean",
+          schmockTrueProbability: 0.8,
+        } as JSONSchema7 & { schmockTrueProbability: number },
+      },
+      required: ["isActive"],
+    };
+
+    let trueCount = 0;
+    const runs = 200;
+    for (let i = 0; i < runs; i++) {
+      const result = (await generateFromSchema({ schema })) as Record<
+        string,
+        unknown
+      >;
+      if (result.isActive === true) {
+        trueCount++;
+      }
+    }
+
+    const trueRate = trueCount / runs;
+    // With probability 0.8, expect trueRate to be roughly in [0.65, 0.95]
+    expect(trueRate).toBeGreaterThan(0.55);
+    expect(trueRate).toBeLessThan(0.95);
+  });
+});
+
+describe("postProcessGenerated — recursive processing", () => {
+  it("nested object properties are recursively processed", async () => {
+    const schema: JSONSchema7 = {
+      type: "object",
+      properties: {
+        outer: {
+          type: "object",
+          properties: {
+            inner: {
+              type: "boolean",
+              schmockTrueProbability: 1.0,
+            } as JSONSchema7 & { schmockTrueProbability: number },
+          },
+          required: ["inner"],
+        },
+      },
+      required: ["outer"],
+    };
+
+    // With schmockTrueProbability = 1.0, every run should yield true
+    for (let i = 0; i < 10; i++) {
+      const result = (await generateFromSchema({ schema })) as {
+        outer: { inner: boolean };
+      };
+      expect(result.outer.inner).toBe(true);
+    }
+  });
+
+  it("array items are recursively processed", async () => {
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          flag: {
+            type: "boolean",
+            schmockTrueProbability: 1.0,
+          } as JSONSchema7 & { schmockTrueProbability: number },
+        },
+        required: ["flag"],
+      },
+    };
+
+    const result = (await generateFromSchema({ schema, count: 5 })) as Array<{
+      flag: boolean;
+    }>;
+
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(5);
+    for (const item of result) {
+      expect(item.flag).toBe(true);
+    }
+  });
+
+  it("non-object data passes through unchanged", async () => {
+    // A string schema should pass through postProcessGenerated without issues
+    const schema: JSONSchema7 = {
+      type: "string",
+    };
+
+    const result = await generateFromSchema({ schema });
+    expect(typeof result).toBe("string");
+  });
+});