@schmock/faker 1.10.0 → 1.13.0

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

@@ -1,6 +1,6 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
-import { generateFromSchema, fakerPlugin } from "../index";
+import { fakerPlugin, generateFromSchema } from "../index";
 
 const feature = await loadFeature("../../features/faker-plugin.feature");
 
@@ -8,153 +8,201 @@ describeFeature(feature, ({ Scenario }) => {
   let generated: any;
   let error: Error | null = null;
 
-  Scenario("Generate object from simple schema", ({ Given, When, Then, And }) => {
-    let schema: any;
-
-    Given("I create a schema plugin with:", (_, docString: string) => {
-      schema = JSON.parse(docString);
-    });
-
-    When("I generate data from the schema", () => {
-      generated = generateFromSchema({ schema });
-    });
-
-    Then("the generated data should have property {string} of type {string}", (_, prop: string, type: string) => {
-      expect(generated).toHaveProperty(prop);
-      expect(typeof generated[prop]).toBe(type);
-    });
-
-    And("the generated data should have property {string} of type {string}", (_, prop: string, type: string) => {
-      expect(generated).toHaveProperty(prop);
-      expect(typeof generated[prop]).toBe(type);
-    });
-  });
-
-  Scenario("Generate array of items with explicit count", ({ Given, When, Then }) => {
-    let schema: any;
-    let count: number;
-
-    Given("I create a schema plugin for array with count {int}:", (_, cnt: number, docString: string) => {
-      schema = JSON.parse(docString);
-      count = cnt;
-    });
-
-    When("I generate data from the schema", () => {
-      generated = generateFromSchema({ schema, count });
-    });
-
-    Then("the generated data should be an array of length {int}", (_, length: number) => {
-      expect(Array.isArray(generated)).toBe(true);
-      expect(generated).toHaveLength(length);
-    });
-  });
-
-  Scenario("Template preserves string values for mixed templates", ({ Given, When, Then }) => {
-    let template: string;
-    let result: any;
-
-    Given("I create a schema plugin with template override {string}", (_, tmpl: string) => {
-      template = tmpl;
-    });
-
-    When("I generate data with param {string} set to {string}", (_, paramName: string, paramValue: string) => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          value: { type: "string" as const },
+  Scenario(
+    "Generate object from simple schema",
+    ({ Given, When, Then, And }) => {
+      let schema: any;
+
+      Given("I create a schema plugin with:", (_, docString: string) => {
+        schema = JSON.parse(docString);
+      });
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({ schema });
+      });
+
+      Then(
+        "the generated data should have property {string} of type {string}",
+        (_, prop: string, type: string) => {
+          expect(generated).toHaveProperty(prop);
+          expect(typeof generated[prop]).toBe(type);
+        },
+      );
+
+      And(
+        "the generated data should have property {string} of type {string}",
+        (_, prop: string, type: string) => {
+          expect(generated).toHaveProperty(prop);
+          expect(typeof generated[prop]).toBe(type);
         },
-      };
-      result = generateFromSchema({
-        schema,
-        overrides: { value: template },
-        params: { [paramName]: paramValue },
+      );
+    },
+  );
+
+  Scenario(
+    "Generate array of items with explicit count",
+    ({ Given, When, Then }) => {
+      let schema: any;
+      let count: number;
+
+      Given(
+        "I create a schema plugin for array with count {int}:",
+        (_, cnt: number, docString: string) => {
+          schema = JSON.parse(docString);
+          count = cnt;
+        },
+      );
+
+      When("I generate data from the schema", async () => {
+        generated = await generateFromSchema({ schema, count });
       });
-    });
-
-    Then("the template result should be the string {string}", (_, expected: string) => {
-      expect(result.value).toBe(expected);
-      expect(typeof result.value).toBe("string");
-    });
-  });
-
-  Scenario("Multiple schema plugin instances do not share state", ({ Given, When, Then }) => {
-    let plugin1: any;
-    let plugin2: any;
-    let data1: any;
-    let data2: any;
-
-    Given("I create two separate schema plugin instances", () => {
-      const schema = {
-        type: "object" as const,
-        properties: {
-          name: { type: "string" as const },
+
+      Then(
+        "the generated data should be an array of length {int}",
+        (_, length: number) => {
+          expect(Array.isArray(generated)).toBe(true);
+          expect(generated).toHaveLength(length);
         },
-        required: ["name"],
-      };
-      plugin1 = fakerPlugin({ schema });
-      plugin2 = fakerPlugin({ schema });
-    });
-
-    When("I generate data from both instances", async () => {
-      const ctx = {
-        path: "/test",
-        route: {},
-        method: "GET" as const,
-        params: {},
-        query: {},
-        headers: {},
-        state: new Map(),
-      };
-      const result1 = await plugin1.process(ctx);
-      const result2 = await plugin2.process(ctx);
-      data1 = result1.response;
-      data2 = result2.response;
-    });
-
-    Then("the data from each instance should be independently generated", () => {
-      expect(data1).toBeDefined();
-      expect(data2).toBeDefined();
-      expect(typeof data1.name).toBe("string");
-      expect(typeof data2.name).toBe("string");
-    });
-  });
-
-  Scenario("Invalid schema is rejected at plugin creation time", ({ Given, Then }) => {
-    Given("I attempt to create a schema plugin with invalid schema", () => {
-      error = null;
-      try {
-        fakerPlugin({ schema: {} as any });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a SchemaValidationError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.name).toBe("SchemaValidationError");
-    });
-  });
-
-  Scenario("Faker method validation checks actual method existence", ({ Given, Then }) => {
-    Given("I attempt to create a schema with faker method {string}", (_, fakerMethod: string) => {
-      error = null;
-      try {
+      );
+    },
+  );
+
+  Scenario(
+    "Template preserves string values for mixed templates",
+    ({ Given, When, Then }) => {
+      let template: string;
+      let result: any;
+
+      Given(
+        "I create a schema plugin with template override {string}",
+        (_, tmpl: string) => {
+          template = tmpl;
+        },
+      );
+
+      When(
+        "I generate data with param {string} set to {string}",
+        async (_, paramName: string, paramValue: string) => {
+          const schema = {
+            type: "object" as const,
+            properties: {
+              value: { type: "string" as const },
+            },
+          };
+          result = await generateFromSchema({
+            schema,
+            overrides: { value: template },
+            params: { [paramName]: paramValue },
+          });
+        },
+      );
+
+      Then(
+        "the template result should be the string {string}",
+        (_, expected: string) => {
+          expect(result.value).toBe(expected);
+          expect(typeof result.value).toBe("string");
+        },
+      );
+    },
+  );
+
+  Scenario(
+    "Multiple schema plugin instances do not share state",
+    ({ Given, When, Then }) => {
+      let plugin1: any;
+      let plugin2: any;
+      let data1: any;
+      let data2: any;
+
+      Given("I create two separate schema plugin instances", () => {
         const schema = {
           type: "object" as const,
           properties: {
-            field: { type: "string" as const, faker: fakerMethod },
+            name: { type: "string" as const },
           },
+          required: ["name"],
+        };
+        plugin1 = fakerPlugin({ schema });
+        plugin2 = fakerPlugin({ schema });
+      });
+
+      When("I generate data from both instances", async () => {
+        const ctx = {
+          path: "/test",
+          route: {},
+          method: "GET" as const,
+          params: {},
+          query: {},
+          headers: {},
+          state: new Map(),
         };
-        fakerPlugin({ schema: schema as any });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a SchemaValidationError with message {string}", (_, message: string) => {
-      expect(error).not.toBeNull();
-      expect(error!.name).toBe("SchemaValidationError");
-      expect(error!.message).toContain(message);
-    });
-  });
+        const result1 = await plugin1.process(ctx);
+        const result2 = await plugin2.process(ctx);
+        data1 = result1.response;
+        data2 = result2.response;
+      });
+
+      Then(
+        "the data from each instance should be independently generated",
+        () => {
+          expect(data1).toBeDefined();
+          expect(data2).toBeDefined();
+          expect(typeof data1.name).toBe("string");
+          expect(typeof data2.name).toBe("string");
+        },
+      );
+    },
+  );
+
+  Scenario(
+    "Invalid schema is rejected at plugin creation time",
+    ({ Given, Then }) => {
+      Given("I attempt to create a schema plugin with invalid schema", () => {
+        error = null;
+        try {
+          fakerPlugin({ schema: {} as any });
+        } catch (e) {
+          error = e as Error;
+        }
+      });
+
+      Then("it should throw a SchemaValidationError", () => {
+        expect(error).not.toBeNull();
+        expect(error?.name).toBe("SchemaValidationError");
+      });
+    },
+  );
+
+  Scenario(
+    "Faker method validation checks actual method existence",
+    ({ Given, Then }) => {
+      Given(
+        "I attempt to create a schema with faker method {string}",
+        (_, fakerMethod: string) => {
+          error = null;
+          try {
+            const schema = {
+              type: "object" as const,
+              properties: {
+                field: { type: "string" as const, faker: fakerMethod },
+              },
+            };
+            fakerPlugin({ schema: schema as any });
+          } catch (e) {
+            error = e as Error;
+          }
+        },
+      );
+
+      Then(
+        "it should throw a SchemaValidationError with message {string}",
+        (_, message: string) => {
+          expect(error).not.toBeNull();
+          expect(error?.name).toBe("SchemaValidationError");
+          expect(error?.message).toContain(message);
+        },
+      );
+    },
+  );
 });

package/src/test-utils.ts

@@ -117,16 +117,17 @@ export const validators = {
     };
 
     // Generate multiple samples to check for patterns
-    const mappedSamples = Array.from(
-      { length: 10 },
-      () => generateFromSchema({ schema: mappedSchema })[fieldName],
-    );
+    const mappedSamples: any[] = [];
+    for (let i = 0; i < 10; i++) {
+      const result = await generateFromSchema({ schema: mappedSchema });
+      mappedSamples.push(result[fieldName]);
+    }
 
-    const unmappedSamples = Array.from(
-      { length: 10 },
-      () =>
-        generateFromSchema({ schema: unmappedSchema }).unmappedRandomField12345,
-    );
+    const unmappedSamples: any[] = [];
+    for (let i = 0; i < 10; i++) {
+      const result = await generateFromSchema({ schema: unmappedSchema });
+      unmappedSamples.push(result.unmappedRandomField12345);
+    }
 
     // If field is mapped to a specific faker method, it should have different characteristics
     // than the generic unmapped field
@@ -246,16 +247,22 @@ export const performance = {
 
 // Test Data Generators
 export const generate = {
-  samples: <T>(schema: JSONSchema7, count = 10, options?: any): T[] => {
-    return Array.from({ length: count }, () =>
-      generateFromSchema({ schema, ...options }),
-    );
+  samples: async <T>(
+    schema: JSONSchema7,
+    count = 10,
+    options?: any,
+  ): Promise<T[]> => {
+    const results: T[] = [];
+    for (let i = 0; i < count; i++) {
+      results.push(await generateFromSchema({ schema, ...options }));
+    }
+    return results;
   },
 
-  withSeed: (schema: JSONSchema7, _seed?: number): any => {
+  withSeed: async (schema: JSONSchema7, _seed?: number): Promise<any> => {
     // Note: faker.js doesn't support seeding in the same way,
     // but we can at least ensure consistent test behavior
-    return generateFromSchema({ schema });
+    return await generateFromSchema({ schema });
   },
 };
 
@@ -288,21 +295,30 @@ export const stats = {
 
 // Schema Validation Test Helpers
 export const schemaTests = {
-  expectValid: (schema: JSONSchema7): void => {
-    expect(() => generateFromSchema({ schema })).not.toThrow();
+  expectValid: async (schema: JSONSchema7): Promise<void> => {
+    await expect(generateFromSchema({ schema })).resolves.not.toThrow();
   },
 
-  expectInvalid: (schema: any, errorMessage?: string | RegExp): void => {
+  expectInvalid: async (
+    schema: any,
+    errorMessage?: string | RegExp,
+  ): Promise<void> => {
     if (errorMessage) {
-      expect(() => generateFromSchema({ schema })).toThrow(errorMessage);
+      await expect(generateFromSchema({ schema })).rejects.toThrow(
+        errorMessage,
+      );
     } else {
-      expect(() => generateFromSchema({ schema })).toThrow();
+      await expect(generateFromSchema({ schema })).rejects.toThrow();
     }
   },
 
-  expectSchemaError: (schema: any, path: string, issue?: string): void => {
+  expectSchemaError: async (
+    schema: any,
+    path: string,
+    issue?: string,
+  ): Promise<void> => {
     try {
-      generateFromSchema({ schema });
+      await generateFromSchema({ schema });
       throw new Error("Expected schema validation to fail");
     } catch (error: any) {
       expect(error.name).toBe("SchemaValidationError");