@schmock/faker 1.12.0 → 2.0.0

package/src/data-quality.test.ts

@@ -3,12 +3,12 @@ import { generate, schemas, stats, validators } from "./test-utils";
 
 describe("Data Quality and Statistical Properties", () => {
   describe("Randomness and Distribution", () => {
-    it("generates diverse values for string fields", () => {
+    it("generates diverse values for string fields", async () => {
       const schema = schemas.simple.object({
         text: schemas.simple.string(),
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
       const values = samples.map((s) => s.text);
 
       // Should have high uniqueness
@@ -20,7 +20,7 @@ describe("Data Quality and Statistical Properties", () => {
       expect(entropy).toBeGreaterThan(4); // High randomness
     });
 
-    it("generates well-distributed numeric values", () => {
+    it("generates well-distributed numeric values", async () => {
       const schema = schemas.simple.object({
         value: {
           type: "number",
@@ -29,7 +29,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 200);
+      const samples = await generate.samples<any>(schema, 200);
       const values = samples.map((s) => s.value);
 
       // Check distribution
@@ -48,7 +48,7 @@ describe("Data Quality and Statistical Properties", () => {
       expect(variance).toBeGreaterThan(100); // Good spread of values
     });
 
-    it("generates diverse enum selections", () => {
+    it("generates diverse enum selections", async () => {
       const schema = schemas.simple.object({
         status: {
           type: "string",
@@ -56,7 +56,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
       const distribution = stats.distribution(samples.map((s) => s.status));
 
       // All enum values should be used
@@ -71,12 +71,12 @@ describe("Data Quality and Statistical Properties", () => {
       expect(maxCount / minCount).toBeLessThan(5);
     });
 
-    it("generates diverse boolean values", () => {
+    it("generates diverse boolean values", async () => {
       const schema = schemas.simple.object({
         flag: { type: "boolean" },
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
       const trueCount = samples.filter((s) => s.flag === true).length;
       const falseCount = samples.filter((s) => s.flag === false).length;
 
@@ -88,12 +88,12 @@ describe("Data Quality and Statistical Properties", () => {
   });
 
   describe("Format Compliance", () => {
-    it("generates valid email formats consistently", () => {
+    it("generates valid email formats consistently", async () => {
       const schema = schemas.simple.object({
         email: { type: "string", format: "email" },
       });
 
-      const samples = generate.samples<any>(schema, 50);
+      const samples = await generate.samples<any>(schema, 50);
 
       samples.forEach((sample) => {
         // RFC 5322 simplified regex
@@ -115,12 +115,12 @@ describe("Data Quality and Statistical Properties", () => {
       expect(uniqueness).toBeGreaterThan(0.8);
     });
 
-    it("generates valid UUIDs consistently", () => {
+    it("generates valid UUIDs consistently", async () => {
       const schema = schemas.simple.object({
         id: { type: "string", format: "uuid" },
       });
 
-      const samples = generate.samples<any>(schema, 50);
+      const samples = await generate.samples<any>(schema, 50);
       const uuidRegex =
         /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
@@ -134,12 +134,12 @@ describe("Data Quality and Statistical Properties", () => {
       expect(uniqueness).toBe(1);
     });
 
-    it("generates valid dates with reasonable ranges", () => {
+    it("generates valid dates with reasonable ranges", async () => {
       const schema = schemas.simple.object({
         created: { type: "string", format: "date-time" },
       });
 
-      const samples = generate.samples<any>(schema, 50);
+      const samples = await generate.samples<any>(schema, 50);
 
       samples.forEach((sample) => {
         const date = new Date(sample.created);
@@ -156,12 +156,12 @@ describe("Data Quality and Statistical Properties", () => {
       });
     });
 
-    it("generates valid URLs when specified", () => {
+    it("generates valid URLs when specified", async () => {
       const schema = schemas.simple.object({
         website: { type: "string", format: "uri" },
       });
 
-      const samples = generate.samples<any>(schema, 20);
+      const samples = await generate.samples<any>(schema, 20);
 
       samples.forEach((sample) => {
         if (sample.website) {
@@ -175,29 +175,29 @@ describe("Data Quality and Statistical Properties", () => {
   });
 
   describe("Constraint Satisfaction", () => {
-    it("respects string length constraints consistently", () => {
+    it("respects string length constraints consistently", async () => {
       const schema = schemas.simple.object({
-        username: {
+        xyzField: {
           type: "string",
           minLength: 5,
           maxLength: 15,
         },
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
 
       samples.forEach((sample) => {
-        expect(sample.username.length).toBeGreaterThanOrEqual(5);
-        expect(sample.username.length).toBeLessThanOrEqual(15);
+        expect(sample.xyzField.length).toBeGreaterThanOrEqual(5);
+        expect(sample.xyzField.length).toBeLessThanOrEqual(15);
       });
 
       // Should use various lengths, not always min or max
-      const lengths = samples.map((s) => s.username.length);
+      const lengths = samples.map((s) => s.xyzField.length);
       const uniqueLengths = new Set(lengths);
       expect(uniqueLengths.size).toBeGreaterThan(3);
     });
 
-    it("respects numeric ranges with good distribution", () => {
+    it("respects numeric ranges with good distribution", async () => {
       const schema = schemas.simple.object({
         age: {
           type: "integer",
@@ -206,7 +206,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
       const ages = samples.map((s) => s.age);
 
       // All should be in range
@@ -225,7 +225,7 @@ describe("Data Quality and Statistical Properties", () => {
       expect(ages.some((age) => age >= 58)).toBe(true);
     });
 
-    it("maintains array uniqueness when specified", () => {
+    it("maintains array uniqueness when specified", async () => {
       const schema = schemas.simple.object({
         tags: {
           type: "array",
@@ -236,7 +236,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 20);
+      const samples = await generate.samples<any>(schema, 20);
 
       samples.forEach((sample) => {
         expect(sample.tags).toHaveLength(5);
@@ -254,14 +254,14 @@ describe("Data Quality and Statistical Properties", () => {
   });
 
   describe("Realistic Data Generation", () => {
-    it("generates realistic person names", () => {
+    it("generates realistic person names", async () => {
       const schema = schemas.simple.object({
         firstName: { type: "string" },
         lastName: { type: "string" },
         fullName: { type: "string" },
       });
 
-      const samples = generate.samples<any>(schema, 50);
+      const samples = await generate.samples<any>(schema, 50);
 
       samples.forEach((sample) => {
         // First names should be properly capitalized and reasonable length
@@ -286,14 +286,14 @@ describe("Data Quality and Statistical Properties", () => {
       expect(validators.uniquenessRatio(firstNames)).toBeGreaterThan(0.5); // Slightly more forgiving
     });
 
-    it("generates realistic addresses", () => {
+    it("generates realistic addresses", async () => {
       const schema = schemas.simple.object({
         street: { type: "string" },
         city: { type: "string" },
         zipcode: { type: "string" },
       });
 
-      const samples = generate.samples<any>(schema, 30);
+      const samples = await generate.samples<any>(schema, 30);
 
       samples.forEach((sample) => {
         // Street addresses should have numbers and street names
@@ -310,7 +310,7 @@ describe("Data Quality and Statistical Properties", () => {
       });
     });
 
-    it("generates consistent related data", () => {
+    it("generates consistent related data", async () => {
       const schema = schemas.simple.object({
         user: {
           type: "object",
@@ -323,7 +323,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 20);
+      const samples = await generate.samples<any>(schema, 20);
 
       samples.forEach((sample) => {
         // All fields should be present and be strings
@@ -340,7 +340,7 @@ describe("Data Quality and Statistical Properties", () => {
   });
 
   describe("Edge Cases and Boundaries", () => {
-    it("handles empty strings when allowed", () => {
+    it("handles empty strings when allowed", async () => {
       const schema = schemas.simple.object({
         optional: {
           type: "string",
@@ -348,7 +348,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 50);
+      const samples = await generate.samples<any>(schema, 50);
 
       // All should be valid strings respecting minLength constraint
       samples.forEach((sample) => {
@@ -362,7 +362,7 @@ describe("Data Quality and Statistical Properties", () => {
       expect(uniqueLengths.size).toBeGreaterThan(1);
     });
 
-    it("handles zero and negative numbers appropriately", () => {
+    it("handles zero and negative numbers appropriately", async () => {
       const schema = schemas.simple.object({
         balance: {
           type: "number",
@@ -371,7 +371,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 100);
+      const samples = await generate.samples<any>(schema, 100);
       const balances = samples.map((s) => s.balance);
 
       // Should include negative and positive values
@@ -387,7 +387,7 @@ describe("Data Quality and Statistical Properties", () => {
       });
     });
 
-    it("generates boundary values occasionally", () => {
+    it("generates boundary values occasionally", async () => {
       const schema = schemas.simple.object({
         score: {
           type: "integer",
@@ -396,7 +396,7 @@ describe("Data Quality and Statistical Properties", () => {
         },
       });
 
-      const samples = generate.samples<any>(schema, 200);
+      const samples = await generate.samples<any>(schema, 200);
       const scores = samples.map((s) => s.score);
 
       // Should respect the boundaries and generate diverse values

package/src/error-handling.test.ts

@@ -5,9 +5,9 @@ import { schemas } from "./test-utils";
 
 describe("Schema Error Handling", () => {
   describe("Validation Error Messages", () => {
-    it("provides clear error for empty schemas", () => {
+    it("provides clear error for empty schemas", async () => {
       try {
-        generateFromSchema({ schema: {} as any });
+        await generateFromSchema({ schema: {} as any });
         expect.fail("Should have thrown");
       } catch (error: any) {
         expect(error.name).toBe("SchemaValidationError");
@@ -16,9 +16,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("provides clear error for invalid types", () => {
+    it("provides clear error for invalid types", async () => {
       try {
-        generateFromSchema({ schema: { type: "invalid" as any } });
+        await generateFromSchema({ schema: { type: "invalid" as any } });
         expect.fail("Should have thrown");
       } catch (error: any) {
         expect(error.name).toBe("SchemaValidationError");
@@ -28,9 +28,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("provides helpful suggestions for common mistakes", () => {
+    it("provides helpful suggestions for common mistakes", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: "should be object" as any,
@@ -45,9 +45,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("includes schema path in error messages", () => {
+    it("includes schema path in error messages", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -69,9 +69,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("validates faker method namespaces with helpful errors", () => {
+    it("validates faker method namespaces with helpful errors", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -89,9 +89,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("validates array schemas must have items", () => {
+    it("validates array schemas must have items", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "array",
             items: null as any,
@@ -108,9 +108,9 @@ describe("Schema Error Handling", () => {
   });
 
   describe("Resource Limit Errors", () => {
-    it("provides clear error for array size limits", () => {
+    it("provides clear error for array size limits", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "array",
             items: { type: "string" },
@@ -125,10 +125,10 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("provides clear error for nesting depth", () => {
+    it("provides clear error for nesting depth", async () => {
       try {
         const deepSchema = schemas.nested.deep(15);
-        generateFromSchema({ schema: deepSchema });
+        await generateFromSchema({ schema: deepSchema });
         expect.fail("Should have thrown");
       } catch (error: any) {
         // Should throw some kind of error for nesting depth
@@ -137,9 +137,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("detects memory risks from nested arrays", () => {
+    it("detects memory risks from nested arrays", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -171,9 +171,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("provides actionable error messages for limits", () => {
+    it("provides actionable error messages for limits", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "array",
             items: { type: "string" },
@@ -190,9 +190,9 @@ describe("Schema Error Handling", () => {
   });
 
   describe("Schema Generation Errors", () => {
-    it("wraps json-schema-faker errors appropriately", () => {
+    it("wraps json-schema-faker errors appropriately", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "string",
             pattern: "[", // Invalid regex
@@ -206,7 +206,7 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("includes context in generation errors", () => {
+    it("includes context in generation errors", async () => {
       const plugin = fakerPlugin({
         schema: {
           type: "string",
@@ -226,7 +226,7 @@ describe("Schema Error Handling", () => {
       };
 
       try {
-        plugin.process(context);
+        await plugin.process(context);
         expect.fail("Should have thrown");
       } catch (error: any) {
         // Should throw some kind of error
@@ -234,9 +234,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("handles circular reference errors", () => {
+    it("handles circular reference errors", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -251,9 +251,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("handles missing reference errors", () => {
+    it("handles missing reference errors", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -264,7 +264,7 @@ describe("Schema Error Handling", () => {
         expect.fail("Should have thrown");
       } catch (error: any) {
         // json-schema-faker throws its own error
-        expect(error.message).toContain("not found");
+        expect(error.message).toContain("Unresolved $ref");
       }
     });
   });
@@ -282,13 +282,13 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("handles null context gracefully", () => {
+    it("handles null context gracefully", async () => {
       const plugin = fakerPlugin({
         schema: schemas.simple.object({ id: schemas.simple.number() }),
       });
 
       // Should not crash with null params
-      const result = plugin.process({
+      const result = await plugin.process({
         method: "GET",
         path: "/test",
         params: null as any,
@@ -302,9 +302,9 @@ describe("Schema Error Handling", () => {
       expect(result.response).toHaveProperty("id");
     });
 
-    it("preserves original error stack traces", () => {
+    it("preserves original error stack traces", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "string",
             pattern: "[",
@@ -320,23 +320,23 @@ describe("Schema Error Handling", () => {
   });
 
   describe("Error Recovery", () => {
-    it("can generate after validation errors", () => {
+    it("can generate after validation errors", async () => {
       // First attempt with invalid schema
       try {
-        generateFromSchema({ schema: { type: "invalid" as any } });
+        await generateFromSchema({ schema: { type: "invalid" as any } });
       } catch (_error) {
         // Expected
       }
 
       // Should be able to generate with valid schema
-      const result = generateFromSchema({
+      const result = await generateFromSchema({
         schema: schemas.simple.object({ id: schemas.simple.number() }),
       });
 
       expect(result).toHaveProperty("id");
     });
 
-    it("plugin continues to work after errors", () => {
+    it("plugin continues to work after errors", async () => {
       const plugin = fakerPlugin({
         schema: schemas.simple.object({ id: schemas.simple.number() }),
       });
@@ -353,8 +353,8 @@ describe("Schema Error Handling", () => {
       };
 
       // Multiple calls should work
-      const result1 = plugin.process(context);
-      const result2 = plugin.process(context);
+      const result1 = await plugin.process(context);
+      const result2 = await plugin.process(context);
 
       expect(result1.response).toHaveProperty("id");
       expect(result2.response).toHaveProperty("id");
@@ -362,9 +362,9 @@ describe("Schema Error Handling", () => {
   });
 
   describe("Edge Case Error Handling", () => {
-    it("handles deeply nested validation errors", () => {
+    it("handles deeply nested validation errors", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: {
@@ -399,9 +399,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("handles multiple validation errors (reports first)", () => {
+    it("handles multiple validation errors (reports first)", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "invalid" as any,
             properties: "also invalid" as any,
@@ -415,19 +415,17 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("handles non-Error objects in catch blocks", () => {
+    it("handles non-Error objects in catch blocks", async () => {
       // This is more about the implementation being defensive
       const plugin = fakerPlugin({
         schema: schemas.simple.object({ id: schemas.simple.number() }),
       });
 
       // Even with weird inputs, should handle gracefully
-      expect(() => {
-        plugin.process({} as any);
-      }).not.toThrow();
+      await expect(plugin.process({} as any)).resolves.not.toThrow();
     });
 
-    it("handles schemas that generate invalid JSON", () => {
+    it("handles schemas that generate invalid JSON", async () => {
       // Some edge cases might generate circular structures
       const schema: JSONSchema7 = {
         type: "object",
@@ -436,7 +434,7 @@ describe("Schema Error Handling", () => {
         },
       };
 
-      const result = generateFromSchema({ schema });
+      const result = await generateFromSchema({ schema });
 
       // Should be serializable
       expect(() => JSON.stringify(result)).not.toThrow();
@@ -444,18 +442,18 @@ describe("Schema Error Handling", () => {
   });
 
   describe("Error Message Quality", () => {
-    it("uses consistent error message format", () => {
+    it("uses consistent error message format", async () => {
       const errors: any[] = [];
 
       // Collect various errors
       try {
-        generateFromSchema({ schema: {} as any });
+        await generateFromSchema({ schema: {} as any });
       } catch (e) {
         errors.push(e);
       }
 
       try {
-        generateFromSchema({ schema: { type: "invalid" as any } });
+        await generateFromSchema({ schema: { type: "invalid" as any } });
       } catch (e) {
         errors.push(e);
       }
@@ -469,9 +467,9 @@ describe("Schema Error Handling", () => {
       });
     });
 
-    it("avoids exposing internal implementation details", () => {
+    it("avoids exposing internal implementation details", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "string",
             pattern: "[",
@@ -487,9 +485,9 @@ describe("Schema Error Handling", () => {
       }
     });
 
-    it("provides actionable error messages", () => {
+    it("provides actionable error messages", async () => {
       try {
-        generateFromSchema({
+        await generateFromSchema({
           schema: {
             type: "object",
             properties: [] as any, // Wrong type