@schmock/faker 2.3.0 → 2.3.1

package/src/index.test.ts

@@ -1,1320 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { version as packageVersion } from "../package.json";
-import { fakerPlugin, generateFromSchema } from "./index";
-import {
-  generate,
-  performance as perf,
-  schemas,
-  schemaTests,
-  stats,
-  validators,
-} from "./test-utils";
-
-describe("Schema Generator", () => {
-  describe("Core Functionality", () => {
-    it("generates data from simple schemas", async () => {
-      const result = await generateFromSchema({
-        schema: schemas.simple.object({
-          id: schemas.simple.number(),
-          name: schemas.simple.string(),
-        }),
-      });
-
-      expect(result).toHaveProperty("id");
-      expect(result).toHaveProperty("name");
-      expect(typeof result.id).toBe("number");
-      expect(typeof result.name).toBe("string");
-    });
-
-    it("generates arrays with specified count", async () => {
-      const schema = schemas.simple.array(
-        schemas.simple.object({ id: schemas.simple.number() }),
-      );
-      const result = await generateFromSchema({ schema, count: 5 });
-
-      expect(Array.isArray(result)).toBe(true);
-      expect(result).toHaveLength(5);
-      result.forEach((item) => {
-        expect(item).toHaveProperty("id");
-        expect(typeof item.id).toBe("number");
-      });
-    });
-
-    it("uses one seeded sequence across a generated array", async () => {
-      const schema: JSONSchema7 = {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "integer" },
-            name: { type: "string" },
-          },
-          required: ["id", "name"],
-        },
-      };
-
-      const first = await generateFromSchema({ schema, count: 5, seed: 42 });
-      const second = await generateFromSchema({ schema, count: 5, 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");
-      }
-      expect(new Set(first.map((item) => JSON.stringify(item))).size).toBe(5);
-    });
-
-    it("generates tuple positions from their respective schemas", async () => {
-      const schema: JSONSchema7 = {
-        type: "array",
-        items: [{ type: "string" }, { type: "integer" }, { type: "boolean" }],
-        minItems: 3,
-        maxItems: 3,
-      };
-
-      const result = await generateFromSchema({ schema, seed: 42 });
-
-      expect(Array.isArray(result)).toBe(true);
-      if (!Array.isArray(result)) {
-        throw new Error("Expected generated data to be a tuple");
-      }
-      expect(result).toHaveLength(3);
-      expect(typeof result[0]).toBe("string");
-      expect(typeof result[1]).toBe("number");
-      expect(typeof result[2]).toBe("boolean");
-    });
-
-    it("generates a nested tuple reached through a definition reference", async () => {
-      const schema: JSONSchema7 = {
-        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,
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema, seed: 42 });
-
-      expect(result).toMatchObject({ payload: expect.any(Array) });
-      if (
-        typeof result !== "object" ||
-        result === null ||
-        !("payload" in result) ||
-        !Array.isArray(result.payload)
-      ) {
-        throw new Error("Expected generated payload to be a tuple");
-      }
-      expect(result.payload).toHaveLength(3);
-      expect(typeof result.payload[0]).toBe("string");
-      expect(typeof result.payload[1]).toBe("number");
-      expect(typeof result.payload[2]).toBe("boolean");
-    });
-
-    it("honors uniqueItems while generating the complete array", async () => {
-      const schema: JSONSchema7 = {
-        type: "array",
-        items: { type: "integer" },
-        minItems: 8,
-        maxItems: 8,
-        uniqueItems: true,
-      };
-
-      const result = await generateFromSchema({ schema, seed: 42 });
-
-      expect(Array.isArray(result)).toBe(true);
-      if (!Array.isArray(result)) {
-        throw new Error("Expected generated data to be an array");
-      }
-      expect(result).toHaveLength(8);
-      expect(new Set(result).size).toBe(8);
-    });
-
-    it("respects array constraints from schema", async () => {
-      const schema = schemas.simple.array(schemas.simple.string(), {
-        minItems: 2,
-        maxItems: 5,
-      });
-      const results = await generate.samples<string[]>(schema, 20);
-
-      results.forEach((result) => {
-        expect(result.length).toBeGreaterThanOrEqual(2);
-        expect(result.length).toBeLessThanOrEqual(5);
-      });
-    });
-
-    it("handles nested schemas correctly", async () => {
-      const schema = schemas.nested.deep(3, schemas.simple.string());
-      const result = await generateFromSchema({ schema });
-
-      expect(result).toHaveProperty("nested");
-      expect(result.nested).toHaveProperty("nested");
-      expect(result.nested.nested).toHaveProperty("nested");
-      expect(typeof result.nested.nested.nested).toBe("string");
-    });
-
-    it("generates consistent data types", async () => {
-      const schema = schemas.complex.apiResponse();
-      const samples = await generate.samples(schema, 10);
-
-      samples.forEach((sample) => {
-        expect(typeof sample.success).toBe("boolean");
-        expect(Array.isArray(sample.data)).toBe(true);
-        expect(typeof sample.meta.page).toBe("number");
-        expect(typeof sample.meta.total).toBe("number");
-      });
-    });
-  });
-
-  describe("Schema Validation", () => {
-    describe("invalid schemas", () => {
-      it("rejects empty schema objects", async () => {
-        await schemaTests.expectInvalid({}, "Schema cannot be empty");
-      });
-
-      it("rejects null and undefined schemas", async () => {
-        await schemaTests.expectInvalid(
-          null,
-          "Schema must be a valid JSON Schema object",
-        );
-        await schemaTests.expectInvalid(
-          undefined,
-          "Schema must be a valid JSON Schema object",
-        );
-      });
-
-      it("rejects non-object schema types", async () => {
-        await schemaTests.expectInvalid(
-          "string",
-          "Schema must be a valid JSON Schema object",
-        );
-        await schemaTests.expectInvalid(
-          123,
-          "Schema must be a valid JSON Schema object",
-        );
-        await schemaTests.expectInvalid(
-          true,
-          "Schema must be a valid JSON Schema object",
-        );
-        await schemaTests.expectInvalid([], "Schema cannot be empty");
-      });
-
-      it("rejects invalid type values", async () => {
-        await schemaTests.expectSchemaError(
-          { type: "invalid" },
-          "$",
-          'Invalid schema type: "invalid"',
-        );
-      });
-
-      it("rejects malformed object properties", async () => {
-        await schemaTests.expectSchemaError(
-          { type: "object", properties: "invalid" },
-          "$.properties",
-          "Properties must be an object mapping",
-        );
-      });
-
-      it("rejects arrays without items", async () => {
-        await schemaTests.expectSchemaError(
-          { type: "array", items: null },
-          "$.items",
-          "Array schema must have valid items definition",
-        );
-      });
-
-      it("validates nested schemas recursively", async () => {
-        await schemaTests.expectSchemaError(
-          {
-            type: "object",
-            properties: {
-              nested: {
-                type: "object",
-                properties: {
-                  bad: { type: "invalid" },
-                },
-              },
-            },
-          },
-          "$.properties.nested.properties.bad",
-          "Invalid schema type",
-        );
-      });
-    });
-
-    describe("resource limits", () => {
-      it("enforces array size limits", async () => {
-        const schema = schemas.simple.array(schemas.simple.string(), {
-          maxItems: 50000,
-        });
-        await expect(generateFromSchema({ schema })).rejects.toThrow(
-          "array_max_items",
-        );
-      });
-
-      it("enforces nesting depth limits", async () => {
-        const deepSchema = schemas.nested.deep(15);
-        await expect(
-          generateFromSchema({ schema: deepSchema }),
-        ).rejects.toThrow("schema_nesting_depth");
-      });
-
-      it("detects circular references", async () => {
-        // Create a circular reference
-        const schema: any = {
-          type: "object",
-          properties: {
-            self: { $ref: "#" },
-          },
-        };
-
-        await schemaTests.expectInvalid(schema, /circular/i);
-      });
-
-      it("prevents memory exhaustion from deep nesting with large arrays", async () => {
-        const schema = {
-          type: "object",
-          properties: {
-            level1: {
-              type: "object",
-              properties: {
-                level2: {
-                  type: "object",
-                  properties: {
-                    level3: {
-                      type: "object",
-                      properties: {
-                        level4: {
-                          type: "array",
-                          items: { type: "string" },
-                          maxItems: 1000,
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        };
-
-        await expect(generateFromSchema({ schema })).rejects.toThrow(
-          /memory|deep_nesting/,
-        );
-      });
-    });
-
-    describe("edge cases", () => {
-      it("handles schemas without explicit type", async () => {
-        const schema = { properties: { name: { type: "string" as const } } };
-        await schemaTests.expectValid(schema);
-      });
-
-      it("handles empty properties object", async () => {
-        const schema = { type: "object" as const, properties: {} };
-        const result = await generateFromSchema({ schema });
-        expect(typeof result).toBe("object");
-      });
-
-      it("handles array with multiple item types", async () => {
-        const schema = {
-          type: "array" as const,
-          items: [
-            { type: "string" as const },
-            { type: "number" as const },
-            { type: "boolean" as const },
-          ],
-        };
-        await schemaTests.expectValid(schema);
-      });
-    });
-  });
-
-  describe("Smart Field Mapping", () => {
-    describe("mapping behavior", () => {
-      it("maps email fields to appropriate generator", async () => {
-        const samples = await generate.samples<any>(
-          schemas.simple.object({
-            email: schemas.simple.string(),
-            userEmail: schemas.simple.string(),
-            contact_email: schemas.simple.string(),
-          }),
-          20,
-        );
-
-        // All email fields should contain @ and .
-        samples.forEach((sample) => {
-          expect(
-            validators.appearsToBeFromCategory([sample.email], "email"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.userEmail], "email"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.contact_email], "email"),
-          ).toBe(true);
-        });
-
-        // Should have good uniqueness (not all the same)
-        const emails = samples.map((s) => s.email);
-        expect(validators.uniquenessRatio(emails)).toBeGreaterThan(0.7);
-      });
-
-      it("maps name fields appropriately", async () => {
-        const samples = await generate.samples<any>(
-          schemas.simple.object({
-            firstName: schemas.simple.string(),
-            first_name: schemas.simple.string(),
-            lastName: schemas.simple.string(),
-            last_name: schemas.simple.string(),
-            name: schemas.simple.string(),
-            fullname: schemas.simple.string(),
-          }),
-          20,
-        );
-
-        samples.forEach((sample) => {
-          // First names should be single words
-          expect(sample.firstName).not.toContain(" ");
-          expect(sample.first_name).not.toContain(" ");
-
-          // Last names should be single words
-          expect(sample.lastName).not.toContain(" ");
-          expect(sample.last_name).not.toContain(" ");
-
-          // Full names should contain spaces
-          expect(sample.name).toContain(" ");
-          expect(sample.fullname).toContain(" ");
-
-          // All should start with capital letters
-          expect(
-            validators.appearsToBeFromCategory([sample.firstName], "name"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.lastName], "name"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.name], "name"),
-          ).toBe(true);
-        });
-
-        // Check uniqueness
-        const firstNames = samples.map((s) => s.firstName);
-        expect(validators.uniquenessRatio(firstNames)).toBeGreaterThan(0.5);
-      });
-
-      it("maps date fields to date generators", async () => {
-        const samples = await generate.samples<any>(
-          schemas.simple.object({
-            createdAt: schemas.simple.string(),
-            created_at: schemas.simple.string(),
-            updatedAt: schemas.simple.string(),
-            updated_at: schemas.simple.string(),
-          }),
-          10,
-        );
-
-        samples.forEach((sample) => {
-          expect(
-            validators.appearsToBeFromCategory([sample.createdAt], "date"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.created_at], "date"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.updatedAt], "date"),
-          ).toBe(true);
-          expect(
-            validators.appearsToBeFromCategory([sample.updated_at], "date"),
-          ).toBe(true);
-        });
-      });
-
-      it("maps UUID fields correctly", async () => {
-        const samples = await generate.samples<any>(
-          schemas.simple.object({
-            uuid: schemas.simple.string(),
-            id: { type: "string" as const, format: "uuid" as const },
-          }),
-          10,
-        );
-
-        samples.forEach((sample) => {
-          expect(
-            validators.appearsToBeFromCategory([sample.uuid], "uuid"),
-          ).toBe(true);
-          expect(validators.appearsToBeFromCategory([sample.id], "uuid")).toBe(
-            true,
-          );
-        });
-      });
-
-      it("does not map unrecognized fields", async () => {
-        const samples = await generate.samples<any>(
-          schemas.simple.object({
-            randomField: schemas.simple.string(),
-            customProperty: schemas.simple.string(),
-            someValue: schemas.simple.string(),
-          }),
-          20,
-        );
-
-        // These should be random strings, not following any specific pattern
-        const randomFields = samples.map((s) => s.randomField);
-        const _customProps = samples.map((s) => s.customProperty);
-
-        // Should not appear to be from any specific category
-        expect(validators.appearsToBeFromCategory(randomFields, "email")).toBe(
-          false,
-        );
-        expect(validators.appearsToBeFromCategory(randomFields, "name")).toBe(
-          false,
-        );
-        expect(validators.appearsToBeFromCategory(randomFields, "uuid")).toBe(
-          false,
-        );
-      });
-
-      it("preserves explicit faker methods over smart mapping", async () => {
-        const schema = schemas.simple.object({
-          email: schemas.withFaker("string", "person.firstName"),
-        });
-
-        const samples = await generate.samples<any>(schema, 10);
-
-        // Should NOT be emails since we explicitly set it to firstName
-        samples.forEach((sample) => {
-          expect(sample.email).not.toContain("@");
-          expect(
-            validators.appearsToBeFromCategory([sample.email], "email"),
-          ).toBe(false);
-        });
-      });
-
-      it("validates faker method namespaces", async () => {
-        const schema = schemas.simple.object({
-          field: schemas.withFaker("string", "invalidnamespace.method"),
-        });
-
-        await schemaTests.expectInvalid(schema, /Invalid faker method/);
-      });
-
-      it("handles all common field mapping categories", async () => {
-        const schema = schemas.simple.object({
-          // Names
-          firstName: schemas.simple.string(),
-          lastName: schemas.simple.string(),
-
-          // Contact
-          email: schemas.simple.string(),
-          phone: schemas.simple.string(),
-          mobile: schemas.simple.string(),
-
-          // Address
-          street: schemas.simple.string(),
-          city: schemas.simple.string(),
-          zipcode: schemas.simple.string(),
-
-          // Business
-          company: schemas.simple.string(),
-          position: schemas.simple.string(),
-
-          // Money
-          price: schemas.simple.string(),
-          amount: schemas.simple.string(),
-
-          // Time
-          createdAt: schemas.simple.string(),
-          updatedAt: schemas.simple.string(),
-
-          // IDs
-          uuid: schemas.simple.string(),
-        });
-
-        const result = await generateFromSchema({ schema });
-
-        // Just verify all fields are generated without checking specific patterns
-        Object.keys(schema.properties).forEach((key) => {
-          expect(result).toHaveProperty(key);
-          expect(typeof result[key]).toBe("string");
-          expect(result[key].length).toBeGreaterThan(0);
-        });
-      });
-    });
-
-    describe("mapping effectiveness", () => {
-      it("generates diverse data for mapped fields", async () => {
-        const schema = schemas.simple.object({
-          email: schemas.simple.string(),
-          name: schemas.simple.string(),
-          phone: schemas.simple.string(),
-        });
-
-        const samples = await generate.samples<any>(schema, 50);
-
-        // Check entropy/diversity
-        const emails = samples.map((s) => s.email);
-        const names = samples.map((s) => s.name);
-        const phones = samples.map((s) => s.phone);
-
-        // Should have high uniqueness for these fields
-        expect(validators.uniquenessRatio(emails)).toBeGreaterThan(0.8);
-        expect(validators.uniquenessRatio(names)).toBeGreaterThan(0.7);
-        expect(validators.uniquenessRatio(phones)).toBeGreaterThan(0.8);
-
-        // Should have good entropy
-        expect(stats.entropy(emails)).toBeGreaterThan(3);
-        expect(stats.entropy(names)).toBeGreaterThan(3);
-      });
-
-      it("mapped fields generate different patterns than unmapped fields", async () => {
-        // This test verifies that our smart mapping actually does something
-        const mappedSamples = (
-          await generate.samples<any>(
-            schemas.simple.object({
-              email: schemas.simple.string(),
-            }),
-            20,
-          )
-        ).map((s) => s.email);
-
-        const unmappedSamples = (
-          await generate.samples<any>(
-            schemas.simple.object({
-              randomFieldXYZ123: schemas.simple.string(),
-            }),
-            20,
-          )
-        ).map((s) => s.randomFieldXYZ123);
-
-        // Email fields should all have @ sign
-        const mappedHasAt = mappedSamples.every((s) => s.includes("@"));
-        const unmappedHasAt = unmappedSamples.every((s) => s.includes("@"));
-
-        expect(mappedHasAt).toBe(true);
-        expect(unmappedHasAt).toBe(false);
-      });
-    });
-  });
-
-  describe("Template Processing", () => {
-    describe("basic template substitution", () => {
-      it("processes param templates", async () => {
-        const schema = schemas.simple.object({
-          userId: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { userId: "{{params.id}}" },
-          params: { id: "123" },
-        });
-
-        expect(result.userId).toBe("123"); // Templates return string values
-      });
-
-      it("processes state templates", async () => {
-        const schema = schemas.simple.object({
-          username: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { username: "{{state.currentUser}}" },
-          state: { currentUser: "alice" },
-        });
-
-        expect(result.username).toBe("alice");
-      });
-
-      it("processes query templates", async () => {
-        const schema = schemas.simple.object({
-          filter: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { filter: "{{query.category}}" },
-          query: { category: "electronics" },
-        });
-
-        expect(result.filter).toBe("electronics");
-      });
-    });
-
-    describe("nested templates", () => {
-      it("resolves deeply nested properties", async () => {
-        const schema = schemas.simple.object({
-          value: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { value: "{{state.user.profile.settings.theme}}" },
-          state: {
-            user: {
-              profile: {
-                settings: {
-                  theme: "dark",
-                },
-              },
-            },
-          },
-        });
-
-        expect(result.value).toBe("dark");
-      });
-
-      it("handles missing nested properties gracefully", async () => {
-        const schema = schemas.simple.object({
-          value: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { value: "{{state.nonexistent.property}}" },
-          state: { other: "value" },
-        });
-
-        expect(result.value).toBe("{{state.nonexistent.property}}");
-      });
-    });
-
-    describe("template edge cases", () => {
-      it("handles multiple templates in one string", async () => {
-        const schema = schemas.simple.object({
-          message: schemas.simple.string(),
-        });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { message: "User {{params.id}} in {{state.location}}" },
-          params: { id: "123" },
-          state: { location: "NYC" },
-        });
-
-        expect(result.message).toBe("User 123 in NYC");
-      });
-
-      it("preserves non-template content", async () => {
-        const schema = schemas.simple.object({ text: schemas.simple.string() });
-        const result = await generateFromSchema({
-          schema,
-          overrides: { text: "Static text with {{params.id}} and more static" },
-          params: { id: "456" },
-        });
-
-        expect(result.text).toBe("Static text with 456 and more static");
-      });
-
-      it("handles malformed templates", async () => {
-        const schema = schemas.simple.object({
-          bad1: schemas.simple.string(),
-          bad2: schemas.simple.string(),
-          bad3: schemas.simple.string(),
-        });
-
-        const result = await generateFromSchema({
-          schema,
-          overrides: {
-            bad1: "{params.id}", // Missing one brace
-            bad2: "{{}}", // Empty template
-            bad3: "{{  }}", // Just spaces
-          },
-          params: { id: "123" },
-        });
-
-        expect(result.bad1).toBe("{params.id}");
-        expect(result.bad2).toBe("{{}}");
-        expect(result.bad3).toBe("{{  }}");
-      });
-
-      it("converts numeric strings appropriately", async () => {
-        const schema = schemas.simple.object({
-          intValue: schemas.simple.number(),
-          floatValue: schemas.simple.number(),
-          stringValue: schemas.simple.string(),
-        });
-
-        const result = await generateFromSchema({
-          schema,
-          overrides: {
-            intValue: "{{params.int}}",
-            floatValue: "{{params.float}}",
-            stringValue: "{{params.mixed}}",
-          },
-          params: {
-            int: "42",
-            float: "3.14",
-            mixed: "abc123",
-          },
-        });
-
-        expect(result.intValue).toBe("42"); // All template values are strings
-        expect(result.floatValue).toBe("3.14");
-        expect(result.stringValue).toBe("abc123");
-      });
-
-      it("handles null and undefined in templates", async () => {
-        const schema = schemas.simple.object({
-          nullValue: schemas.simple.string(),
-          undefinedValue: schemas.simple.string(),
-        });
-
-        const result = await generateFromSchema({
-          schema,
-          overrides: {
-            nullValue: "{{state.nullVal}}",
-            undefinedValue: "{{state.undefinedVal}}",
-          },
-          state: {
-            nullVal: null,
-            undefinedVal: undefined,
-          },
-        });
-
-        expect(result.nullValue).toBe(null); // null values preserved
-        expect(result.undefinedValue).toBe("{{state.undefinedVal}}"); // Template returns original when undefined
-      });
-    });
-
-    describe("template in arrays", () => {
-      it("applies templates to array items", async () => {
-        const schema = schemas.simple.array(
-          schemas.simple.object({ userId: schemas.simple.string() }),
-        );
-
-        const result = await generateFromSchema({
-          schema,
-          count: 3,
-          overrides: { userId: "{{params.baseId}}" },
-          params: { baseId: "user_" },
-        });
-
-        expect(Array.isArray(result)).toBe(true);
-        result.forEach((item) => {
-          expect(item.userId).toBe("user_");
-        });
-      });
-    });
-  });
-
-  describe("Performance", () => {
-    it("generates simple schemas quickly", async () => {
-      const schema = schemas.simple.object({
-        id: schemas.simple.number(),
-        name: schemas.simple.string(),
-      });
-
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
-      );
-
-      expect(duration).toBeLessThan(100); // Should be fast (but reasonable for CI)
-    });
-
-    it("handles large arrays efficiently", async () => {
-      const schema = schemas.simple.array(
-        schemas.simple.object({ id: schemas.simple.number() }),
-        { maxItems: 100 },
-      );
-
-      const { duration } = await perf.measure(() =>
-        generateFromSchema({ schema }),
-      );
-
-      expect(duration).toBeLessThan(500); // Reasonable time for 100 items
-    });
-
-    it("benchmarks show consistent performance", async () => {
-      const schema = schemas.complex.user();
-
-      const benchmark = await perf.benchmark(
-        "user generation",
-        () => generateFromSchema({ schema }),
-        50,
-      );
-
-      expect(benchmark.mean).toBeLessThan(50); // Reasonable for CI
-      // Just check that performance is reasonable, not strict ratios for small values
-      expect(benchmark.max).toBeLessThan(100); // No huge outliers
-    });
-
-    it("deep nesting doesn't cause exponential slowdown", async () => {
-      const shallow = schemas.nested.deep(2);
-      const deep = schemas.nested.deep(5);
-
-      await perf.measure(() => generateFromSchema({ schema: shallow }));
-
-      const { duration: deepTime } = await perf.measure(() =>
-        generateFromSchema({ schema: deep }),
-      );
-
-      // Just ensure it completes in reasonable time
-      expect(deepTime).toBeLessThan(100); // Should complete quickly
-      // The times might be too small to compare ratios reliably
-    });
-  });
-
-  describe("Schema Plugin", () => {
-    it("creates plugin with correct interface", () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({ id: schemas.simple.number() }),
-      });
-
-      expect(plugin).toHaveProperty("name", "faker");
-      expect(plugin).toHaveProperty("version", packageVersion);
-      expect(plugin).toHaveProperty("process");
-      expect(typeof plugin.process).toBe("function");
-    });
-
-    it("validates schema at plugin creation time", () => {
-      expect(() => {
-        fakerPlugin({ schema: {} as any });
-      }).toThrow("Schema cannot be empty");
-
-      expect(() => {
-        fakerPlugin({ schema: { type: "invalid" as any } });
-      }).toThrow("Invalid schema type");
-    });
-
-    it("generates data when processing context", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          id: schemas.simple.number(),
-          name: schemas.simple.string(),
-        }),
-      });
-
-      const mockContext = {
-        method: "GET",
-        path: "/test",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const result = await plugin.process(mockContext);
-
-      expect(result.response).toHaveProperty("id");
-      expect(result.response).toHaveProperty("name");
-      expect(typeof result.response.id).toBe("number");
-      expect(typeof result.response.name).toBe("string");
-    });
-
-    it("passes through existing responses", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({ id: schemas.simple.number() }),
-      });
-
-      const mockContext = {
-        method: "GET",
-        path: "/test",
-        params: {},
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const existingResponse = { custom: "response", data: [1, 2, 3] };
-      const result = await plugin.process(mockContext, existingResponse);
-
-      expect(result.response).toEqual(existingResponse);
-    });
-
-    it("applies overrides with template processing", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({
-          userId: schemas.simple.string(),
-          timestamp: schemas.simple.string(),
-        }),
-        overrides: {
-          userId: "{{params.id}}",
-          timestamp: "{{state.currentTime}}",
-        },
-      });
-
-      const mockContext = {
-        method: "GET",
-        path: "/test/123",
-        params: { id: "123" },
-        query: {},
-        state: new Map(),
-        routeState: { currentTime: "2024-01-01T00:00:00Z" },
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const result = await plugin.process(mockContext);
-
-      expect(result.response.userId).toBe("123"); // Template values are strings
-      expect(result.response.timestamp).toBe("2024-01-01T00:00:00Z");
-    });
-
-    it("handles errors gracefully", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.simple.object({ id: schemas.simple.number() }),
-      });
-
-      // Create a context that might cause issues
-      const badContext = {
-        method: "GET",
-        path: "/test",
-        params: null as any, // This might cause template processing to fail
-        query: {},
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      // Should not throw, should handle gracefully
-      await expect(plugin.process(badContext)).resolves.not.toThrow();
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("provides clear error messages for validation failures", async () => {
-      try {
-        await generateFromSchema({
-          schema: {
-            type: "object",
-            properties: {
-              nested: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    field: {
-                      type: "string",
-                      faker: "invalid.namespace.method",
-                    },
-                  },
-                },
-              },
-            },
-          },
-        });
-        expect.fail("Should have thrown");
-      } catch (error: any) {
-        expect(error.message).toContain("Invalid faker method");
-        expect(error.message).toContain("invalid.namespace.method");
-      }
-    });
-
-    it("wraps generation errors appropriately", async () => {
-      const schema = schemas.simple.object({
-        field: { type: "string" as const, pattern: "[" } as any, // Invalid regex
-      });
-
-      // json-schema-faker 0.6.0 may not throw on invalid regex patterns,
-      // but the result should still be handled gracefully
-      const result = await generateFromSchema({ schema });
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe("Integration", () => {
-    it("works with real-world schemas", async () => {
-      const openAPISchema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uuid" },
-          email: { type: "string", format: "email" },
-          profile: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" },
-              lastName: { type: "string" },
-              age: { type: "integer", minimum: 0, maximum: 120 },
-              interests: {
-                type: "array",
-                items: { type: "string" },
-                maxItems: 10,
-              },
-            },
-            required: ["firstName", "lastName"],
-          },
-          createdAt: { type: "string", format: "date-time" },
-          isActive: { type: "boolean" },
-        },
-        required: ["id", "email", "profile"],
-      };
-
-      const result = await generateFromSchema({ schema: openAPISchema });
-
-      // Verify structure
-      expect(result).toHaveProperty("id");
-      expect(result).toHaveProperty("email");
-      expect(result).toHaveProperty("profile");
-      expect(result.profile).toHaveProperty("firstName");
-      expect(result.profile).toHaveProperty("lastName");
-
-      // Verify formats
-      expect(validators.appearsToBeFromCategory([result.id], "uuid")).toBe(
-        true,
-      );
-      expect(validators.appearsToBeFromCategory([result.email], "email")).toBe(
-        true,
-      );
-      expect(
-        validators.appearsToBeFromCategory([result.createdAt], "date"),
-      ).toBe(true);
-    });
-
-    it("integrates with plugin pipeline", async () => {
-      const plugin = fakerPlugin({
-        schema: schemas.complex.apiResponse(),
-        count: 5,
-      });
-
-      // Simulate plugin pipeline
-      const context = {
-        method: "GET",
-        path: "/api/users",
-        params: {},
-        query: { page: "1" },
-        state: {},
-        headers: {},
-        body: null,
-        route: {},
-      };
-
-      const result1 = await plugin.process(context);
-      const result2 = await plugin.process(context);
-
-      // Should generate different data each time
-      expect(result1.response).not.toEqual(result2.response);
-      expect(Array.isArray(result1.response.data)).toBe(true);
-      expect(Array.isArray(result2.response.data)).toBe(true);
-      // Count was specified at plugin level, not in the schema response
-    });
-  });
-});
-
-describe("Additional Coverage Tests", () => {
-  describe("Schema Enhancement", () => {
-    it("enhances simple fields without existing faker methods", async () => {
-      const schema = schemas.simple.object({
-        email: schemas.simple.string(),
-        phone: schemas.simple.string(),
-        uuid: schemas.simple.string(),
-      });
-
-      const samples = await generate.samples<any>(schema, 5);
-
-      samples.forEach((sample) => {
-        expect(
-          validators.appearsToBeFromCategory([sample.email], "email"),
-        ).toBe(true);
-        expect(
-          validators.appearsToBeFromCategory([sample.phone], "phone"),
-        ).toBe(true);
-        expect(validators.appearsToBeFromCategory([sample.uuid], "uuid")).toBe(
-          true,
-        );
-      });
-    });
-
-    it("preserves explicit faker methods over enhancements", async () => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          email: {
-            type: "string" as const,
-            faker: "lorem.word" as any,
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      // Should use lorem.word, not email pattern
-      expect(result.email).not.toContain("@");
-    });
-
-    it("handles array items with smart field mapping", async () => {
-      const schema = schemas.simple.array(
-        schemas.simple.object({
-          email: schemas.simple.string(),
-          createdAt: schemas.simple.string(),
-        }),
-      );
-
-      const result = await generateFromSchema({ schema, count: 3 });
-
-      result.forEach((item) => {
-        expect(validators.appearsToBeFromCategory([item.email], "email")).toBe(
-          true,
-        );
-        expect(
-          validators.appearsToBeFromCategory([item.createdAt], "date"),
-        ).toBe(true);
-      });
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("handles empty string patterns", async () => {
-      const schema = schemas.simple.object({
-        value: { type: "string" as const, pattern: "" as const },
-      });
-
-      const result = await generateFromSchema({ schema });
-      expect(typeof result.value).toBe("string");
-    });
-
-    it("handles whitespace in templates", async () => {
-      const schema = schemas.simple.object({ value: schemas.simple.string() });
-
-      const result = await generateFromSchema({
-        schema,
-        overrides: { value: "  {{  params.id  }}  " },
-        params: { id: "test" },
-      });
-
-      expect(result.value).toBe("  test  "); // Preserves outer whitespace
-    });
-
-    it("handles boolean type with schema", async () => {
-      const schema = schemas.simple.object({
-        flag: { type: "boolean" as const },
-      });
-
-      const samples = await generate.samples<any>(schema, 20);
-
-      // All samples should have boolean flags
-      samples.forEach((sample) => {
-        expect(typeof sample.flag).toBe("boolean");
-      });
-
-      // At least some variation (or all same value is acceptable for JSF)
-      const trueCount = samples.filter((s) => s.flag === true).length;
-      const falseCount = samples.filter((s) => s.flag === false).length;
-      expect(trueCount + falseCount).toBe(20);
-    });
-
-    it("handles integer vs number types", async () => {
-      const schema = schemas.simple.object({
-        intValue: { type: "integer" as const },
-        numValue: { type: "number" as const },
-      });
-
-      const samples = await generate.samples<any>(schema, 10);
-
-      samples.forEach((sample) => {
-        expect(Number.isInteger(sample.intValue)).toBe(true);
-        expect(typeof sample.numValue).toBe("number");
-      });
-    });
-
-    it("handles null type", async () => {
-      const schema = schemas.simple.object({
-        nullValue: { type: "null" as const },
-      });
-
-      const result = await generateFromSchema({ schema });
-      expect(result.nullValue).toBe(null);
-    });
-
-    it("handles format without explicit type", async () => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          email: { format: "email" as const },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-      expect(result.email).toContain("@");
-    });
-
-    it("generates consistent results with same schema instance", async () => {
-      const schema = schemas.complex.user();
-
-      const results: any[] = [];
-      for (let i = 0; i < 5; i++) {
-        results.push(await generateFromSchema({ schema }));
-      }
-
-      // All should be valid but different
-      results.forEach((result) => {
-        expect(validators.appearsToBeFromCategory([result.id], "uuid")).toBe(
-          true,
-        );
-        expect(
-          validators.appearsToBeFromCategory([result.email], "email"),
-        ).toBe(true);
-      });
-
-      // Should be different instances
-      const emails = results.map((r) => r.email);
-      const uniqueEmails = new Set(emails);
-      expect(uniqueEmails.size).toBeGreaterThan(1);
-    });
-
-    it("handles minProperties and maxProperties constraints", async () => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          prop1: { type: "string" as const },
-          prop2: { type: "string" as const },
-        },
-        minProperties: 2,
-        maxProperties: 4,
-        additionalProperties: { type: "string" as const },
-      };
-
-      const samples = await generate.samples<any>(schema, 10);
-
-      samples.forEach((sample) => {
-        const propCount = Object.keys(sample).length;
-        // Should have at least the defined properties
-        expect(propCount).toBeGreaterThanOrEqual(2);
-        // May not respect maxProperties perfectly but should be reasonable
-        expect(propCount).toBeLessThan(20); // Sanity check
-      });
-    });
-
-    it("handles required fields correctly", async () => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          required1: { type: "string" as const },
-          required2: { type: "number" as const },
-          optional1: { type: "boolean" as const },
-          optional2: { type: "string" as const },
-        },
-        required: ["required1", "required2"],
-      };
-
-      const samples = await generate.samples<any>(schema, 10);
-
-      samples.forEach((sample) => {
-        // Required fields should always be present
-        expect(sample).toHaveProperty("required1");
-        expect(sample).toHaveProperty("required2");
-        expect(typeof sample.required1).toBe("string");
-        expect(typeof sample.required2).toBe("number");
-
-        // Optional fields may or may not be present
-        if ("optional1" in sample) {
-          expect(typeof sample.optional1).toBe("boolean");
-        }
-      });
-    });
-  });
-});