@schmock/faker 2.2.2 → 2.3.0

package/src/post-process.test.ts

@@ -8,80 +8,106 @@ import { generateFromSchema } from "./index";
  */
 
 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 },
+  it("uses the generation seed for a reproducible nullable distribution", async () => {
+    const nullableString: JSONSchema7 & { schmockNullable: boolean } = {
+      type: "string",
+      schmockNullable: true,
+    };
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { value: nullableString },
+        required: ["value"],
       },
-      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++;
-      }
-    }
+    const first = await generateFromSchema({ schema, count: 200, seed: 42 });
+    const second = await generateFromSchema({ schema, count: 200, seed: 42 });
 
-    // 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);
+    expect(first).toEqual(second);
+    if (!Array.isArray(first)) {
+      throw new Error("Expected generated nullable data to be an array");
+    }
+    const values = first.map((item) => {
+      if (typeof item !== "object" || item === null || !("value" in item)) {
+        throw new Error("Expected each nullable item to contain value");
+      }
+      return item.value;
+    });
+    expect(values.filter((value) => value === null)).toHaveLength(9);
+    expect(values.filter((value) => typeof value === "string")).toHaveLength(
+      191,
+    );
   });
 });
 
 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 },
+  it("uses the generation seed for deterministic weighted booleans", async () => {
+    const weightedBoolean: JSONSchema7 & {
+      schmockTrueProbability: number;
+    } = {
+      type: "boolean",
+      schmockTrueProbability: 0.5,
+    };
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { flag: weightedBoolean },
+        required: ["flag"],
       },
-      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 first = await generateFromSchema({ schema, count: 12, seed: 42 });
+    const second = await generateFromSchema({ schema, count: 12, seed: 42 });
+
+    expect(first).toEqual(second);
+    expect(Array.isArray(first)).toBe(true);
+    if (!Array.isArray(first)) {
+      throw new Error("Expected generated data to be an array");
     }
+    const flags = first.flatMap((item) => {
+      if (typeof item !== "object" || item === null || !("flag" in item)) {
+        return [];
+      }
+      return [item.flag];
+    });
+    expect(flags).toContain(true);
+    expect(flags).toContain(false);
+  });
+
+  it("applies a reproducible weighted boolean distribution", async () => {
+    const weightedBoolean: JSONSchema7 & {
+      schmockTrueProbability: number;
+    } = {
+      type: "boolean",
+      schmockTrueProbability: 0.8,
+    };
+    const schema: JSONSchema7 = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { flag: weightedBoolean },
+        required: ["flag"],
+      },
+    };
+
+    const first = await generateFromSchema({ schema, count: 200, seed: 42 });
+    const second = await generateFromSchema({ schema, count: 200, seed: 42 });
 
-    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);
+    expect(first).toEqual(second);
+    if (!Array.isArray(first)) {
+      throw new Error("Expected generated weighted data to be an array");
+    }
+    const flags = first.map((item) => {
+      if (typeof item !== "object" || item === null || !("flag" in item)) {
+        throw new Error("Expected each weighted item to contain flag");
+      }
+      return item.flag;
+    });
+    expect(flags.filter((flag) => flag === true)).toHaveLength(162);
+    expect(flags.filter((flag) => flag === false)).toHaveLength(38);
   });
 });
 

package/src/schema-enhancement.test.ts

@@ -170,10 +170,16 @@ describe("enhanceSchemaWithSmartMapping", () => {
     expect(props.email.faker).toBe("lorem.word");
   });
 
-  it("handles schema without properties gracefully", () => {
+  it("adds useful text generation to an unconstrained root string", () => {
     const schema: JSONSchema7 = { type: "string" };
     const enhanced = enhanceSchemaWithSmartMapping(schema);
-    expect(enhanced).toEqual({ type: "string" });
+    expect(enhanced).toEqual({ type: "string", faker: "lorem.word" });
+  });
+
+  it("preserves an explicit zero minimum length", () => {
+    const schema: JSONSchema7 = { type: "string", minLength: 0 };
+    const enhanced = enhanceSchemaWithSmartMapping(schema);
+    expect(enhanced).toEqual(schema);
   });
 
   it("handles null/undefined schema gracefully", () => {

package/src/schema-enhancement.ts

@@ -9,6 +9,20 @@ interface FakerSchema extends JSONSchema7 {
   schmockTrueProbability?: number;
 }
 
+function needsStringFallback(schema: FakerSchema): boolean {
+  return (
+    schema.type === "string" &&
+    schema.faker === undefined &&
+    schema.format === undefined &&
+    schema.pattern === undefined &&
+    schema.enum === undefined &&
+    schema.const === undefined &&
+    schema.$ref === undefined &&
+    schema.minLength === undefined &&
+    schema.maxLength === undefined
+  );
+}
+
 export function enhanceSchemaWithSmartMapping(
   schema: JSONSchema7,
 ): JSONSchema7 {
@@ -16,7 +30,7 @@ export function enhanceSchemaWithSmartMapping(
     return schema;
   }
 
-  const enhanced = { ...schema } as FakerSchema;
+  const enhanced: FakerSchema = { ...schema };
 
   // Handle object properties
   if (enhanced.properties) {
@@ -38,7 +52,7 @@ export function enhanceSchemaWithSmartMapping(
   for (const keyword of ["allOf", "anyOf", "oneOf"] as const) {
     const branches = enhanced[keyword];
     if (Array.isArray(branches)) {
-      (enhanced as Record<string, unknown>)[keyword] = branches.map((branch) =>
+      enhanced[keyword] = branches.map((branch) =>
         isJSONSchema7(branch) ? enhanceSchemaWithSmartMapping(branch) : branch,
       );
     }
@@ -56,16 +70,16 @@ export function enhanceSchemaWithSmartMapping(
   }
 
   // Recurse into additionalProperties
-  if (
-    enhanced.additionalProperties &&
-    typeof enhanced.additionalProperties === "object" &&
-    !Array.isArray(enhanced.additionalProperties)
-  ) {
+  if (isJSONSchema7(enhanced.additionalProperties)) {
     enhanced.additionalProperties = enhanceSchemaWithSmartMapping(
-      enhanced.additionalProperties as JSONSchema7,
+      enhanced.additionalProperties,
     );
   }
 
+  if (needsStringFallback(enhanced)) {
+    enhanced.faker = "lorem.word";
+  }
+
   return enhanced;
 }
 
@@ -122,6 +136,8 @@ function enhanceFieldSchema(
     if (trueProbability !== undefined) {
       enhanced.schmockTrueProbability = trueProbability;
     }
+  } else if (needsStringFallback(enhanced)) {
+    enhanced.faker = "lorem.word";
   }
 
   return enhanced;

package/src/steps/deterministic-seeds.steps.ts

@@ -16,6 +16,10 @@ const testSchema = {
 describeFeature(feature, ({ Scenario }) => {
   let result1: unknown;
   let result2: unknown;
+  let seededArray1: unknown;
+  let seededArray2: unknown;
+  let differentSeedResult1: unknown;
+  let differentSeedResult2: unknown;
 
   Scenario("Same seed produces same output", ({ Given, When, Then }) => {
     Given("a schema plugin with seed 42", () => {
@@ -32,4 +36,77 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
+  Scenario(
+    "Different seeds produce different output",
+    ({ Given, When, Then }) => {
+      let firstSeed = 0;
+      let secondSeed = 0;
+
+      Given(
+        "a schema plugin using seeds {int} and {int}",
+        (_, seedA: number, seedB: number) => {
+          firstSeed = seedA;
+          secondSeed = seedB;
+        },
+      );
+
+      When("I generate data once with each seed", async () => {
+        differentSeedResult1 = await generateFromSchema({
+          schema: testSchema,
+          seed: firstSeed,
+        });
+        differentSeedResult2 = await generateFromSchema({
+          schema: testSchema,
+          seed: secondSeed,
+        });
+      });
+
+      Then("the differently seeded outputs are distinct", () => {
+        expect(differentSeedResult1).not.toEqual(differentSeedResult2);
+      });
+    },
+  );
+
+  Scenario(
+    "Seeded arrays are reproducible without repeating every item",
+    ({ Given, When, Then, And }) => {
+      let count = 0;
+
+      Given(
+        "an array schema plugin with seed 42 and count {int}",
+        (_, requestedCount: number) => {
+          count = requestedCount;
+        },
+      );
+
+      When("I generate the seeded array twice", async () => {
+        const schema = {
+          type: "array" as const,
+          items: {
+            type: "object" as const,
+            properties: {
+              id: { type: "integer" as const },
+              name: { type: "string" as const },
+            },
+            required: ["id", "name"],
+          },
+        };
+        seededArray1 = await generateFromSchema({ schema, count, seed: 42 });
+        seededArray2 = await generateFromSchema({ schema, count, seed: 42 });
+      });
+
+      Then("both seeded arrays are identical", () => {
+        expect(seededArray1).toEqual(seededArray2);
+      });
+
+      And("the seeded array contains varied items", () => {
+        expect(Array.isArray(seededArray1)).toBe(true);
+        if (!Array.isArray(seededArray1)) {
+          throw new Error("Expected seeded output to be an array");
+        }
+        const serialized = seededArray1.map((item) => JSON.stringify(item));
+        expect(new Set(serialized).size).toBeGreaterThan(1);
+      });
+    },
+  );
 });

package/src/steps/faker-plugin.steps.ts

@@ -1,19 +1,38 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
 import { generateFromSchema } from "../index";
+import { isJSONSchema7 } from "../validation";
 
 const feature = await loadFeature("../../features/faker-plugin.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let generated: any;
+  let generated: unknown;
+
+  function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+
+  function isUnknownArray(value: unknown): value is unknown[] {
+    return Array.isArray(value);
+  }
+
+  function parseSchema(
+    docString: string,
+  ): Schmock.SchemaGenerationContext["schema"] {
+    const parsed: unknown = JSON.parse(docString);
+    if (!isJSONSchema7(parsed)) {
+      throw new Error("Expected feature DocString to contain a JSON Schema");
+    }
+    return parsed;
+  }
 
   Scenario(
     "Generate object from simple schema",
     ({ Given, When, Then, And }) => {
-      let schema: any;
+      let schema: Schmock.SchemaGenerationContext["schema"];
 
       Given("I create a schema plugin with:", (_, docString: string) => {
-        schema = JSON.parse(docString);
+        schema = parseSchema(docString);
       });
 
       When("I generate data from the schema", async () => {
@@ -23,6 +42,9 @@ describeFeature(feature, ({ Scenario }) => {
       Then(
         "the generated data should have property {string} of type {string}",
         (_, prop: string, type: string) => {
+          if (!isRecord(generated)) {
+            throw new Error("Expected generated data to be an object");
+          }
           expect(generated).toHaveProperty(prop);
           expect(typeof generated[prop]).toBe(type);
         },
@@ -31,6 +53,9 @@ describeFeature(feature, ({ Scenario }) => {
       And(
         "the generated data should have property {string} of type {string}",
         (_, prop: string, type: string) => {
+          if (!isRecord(generated)) {
+            throw new Error("Expected generated data to be an object");
+          }
           expect(generated).toHaveProperty(prop);
           expect(typeof generated[prop]).toBe(type);
         },
@@ -41,13 +66,13 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario(
     "Generate array of items with explicit count",
     ({ Given, When, Then }) => {
-      let schema: any;
+      let schema: Schmock.SchemaGenerationContext["schema"];
       let count: number;
 
       Given(
         "I create a schema plugin for array with count {int}:",
         (_, cnt: number, docString: string) => {
-          schema = JSON.parse(docString);
+          schema = parseSchema(docString);
           count = cnt;
         },
       );
@@ -70,7 +95,7 @@ describeFeature(feature, ({ Scenario }) => {
     "Template preserves string values for mixed templates",
     ({ Given, When, Then }) => {
       let template: string;
-      let result: any;
+      let result: unknown;
 
       Given(
         "I create a schema plugin with template override {string}",
@@ -99,6 +124,9 @@ describeFeature(feature, ({ Scenario }) => {
       Then(
         "the template result should be the string {string}",
         (_, expected: string) => {
+          if (!isRecord(result)) {
+            throw new Error("Expected generated data to be an object");
+          }
           expect(result.value).toBe(expected);
           expect(typeof result.value).toBe("string");
         },
@@ -106,4 +134,168 @@ describeFeature(feature, ({ Scenario }) => {
     },
   );
 
+  Scenario(
+    "Generate tuple positions from their respective schemas",
+    ({ Given, When, Then }) => {
+      let schema: Schmock.SchemaGenerationContext["schema"];
+
+      Given(
+        "I create a tuple schema with string, integer, and boolean positions",
+        () => {
+          schema = {
+            type: "array",
+            items: [
+              { type: "string" },
+              { type: "integer" },
+              { type: "boolean" },
+            ],
+            minItems: 3,
+            maxItems: 3,
+          };
+        },
+      );
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({ schema, seed: 42 });
+      });
+
+      Then(
+        "the generated tuple should contain string, number, and boolean values in order",
+        () => {
+          if (!isUnknownArray(generated)) {
+            throw new Error("Expected generated tuple data to be an array");
+          }
+          expect(generated).toHaveLength(3);
+          expect(typeof generated[0]).toBe("string");
+          expect(typeof generated[1]).toBe("number");
+          expect(typeof generated[2]).toBe("boolean");
+        },
+      );
+    },
+  );
+
+  Scenario(
+    "Generate a nested tuple through a schema reference",
+    ({ Given, When, Then }) => {
+      let schema: Schmock.SchemaGenerationContext["schema"];
+
+      Given(
+        "I create an object schema whose payload references a tuple definition",
+        () => {
+          schema = {
+            type: "object",
+            properties: {
+              payload: { $ref: "#/definitions/payloadTuple" },
+            },
+            required: ["payload"],
+            definitions: {
+              payloadTuple: {
+                type: "array",
+                items: [
+                  { type: "string" },
+                  { type: "integer" },
+                  { type: "boolean" },
+                ],
+                minItems: 3,
+                maxItems: 3,
+                additionalItems: false,
+              },
+            },
+          };
+        },
+      );
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({ schema, seed: 42 });
+      });
+
+      Then(
+        "the generated payload tuple should contain string, number, and boolean values in order",
+        () => {
+          if (!isRecord(generated) || !Array.isArray(generated.payload)) {
+            throw new Error("Expected generated payload to be a tuple");
+          }
+          expect(generated.payload).toHaveLength(3);
+          expect(typeof generated.payload[0]).toBe("string");
+          expect(typeof generated.payload[1]).toBe("number");
+          expect(typeof generated.payload[2]).toBe("boolean");
+        },
+      );
+    },
+  );
+
+  Scenario(
+    "Apply overrides to every generated array item",
+    ({ Given, When, Then }) => {
+      let schema: Schmock.SchemaGenerationContext["schema"];
+      let count = 0;
+      let name = "";
+
+      Given(
+        "I create an object array schema with count {int} and override name {string}",
+        (_, requestedCount: number, overrideName: string) => {
+          count = requestedCount;
+          name = overrideName;
+          schema = {
+            type: "array",
+            items: {
+              type: "object",
+              properties: { name: { type: "string" } },
+              required: ["name"],
+            },
+          };
+        },
+      );
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({
+          schema,
+          count,
+          overrides: { name },
+          seed: 42,
+        });
+      });
+
+      Then(
+        "every generated array item should have name {string}",
+        (_, expectedName: string) => {
+          if (!isUnknownArray(generated)) {
+            throw new Error(
+              "Expected generated collection data to be an array",
+            );
+          }
+          for (const item of generated) {
+            expect(item).toMatchObject({ name: expectedName });
+          }
+        },
+      );
+    },
+  );
+
+  Scenario(
+    "Generate useful text for an unconstrained string",
+    ({ Given, When, Then }) => {
+      let schema: Schmock.SchemaGenerationContext["schema"];
+
+      Given("I create a schema plugin with:", (_, docString: string) => {
+        schema = parseSchema(docString);
+      });
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({ schema, seed: 42 });
+      });
+
+      Then(
+        "the generated data should have a non-empty {string}",
+        (_, property: string) => {
+          if (!isRecord(generated)) {
+            throw new Error("Expected generated data to be an object");
+          }
+          const value = generated[property];
+          expect(typeof value).toBe("string");
+          expect(value).not.toBe("");
+        },
+      );
+    },
+  );
 });