@schmock/faker 2.3.0 → 2.3.1

package/src/advanced-features.test.ts

@@ -1,912 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import { describe, expect, it } from "vitest";
-import { generateFromSchema } from "./index";
-import { generate, validators } from "./test-utils";
-
-describe("Advanced Schema Features", () => {
-  describe("Schema Composition", () => {
-    it("handles allOf schema composition", async () => {
-      const schema: JSONSchema7 = {
-        allOf: [
-          {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              age: { type: "number" },
-            },
-            required: ["name"],
-          },
-          {
-            type: "object",
-            properties: {
-              email: { type: "string" },
-              age: { type: "number", minimum: 18 },
-            },
-            required: ["email"],
-          },
-        ],
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      // Should have properties from both schemas
-      expect(result).toHaveProperty("name");
-      expect(result).toHaveProperty("email");
-      expect(result).toHaveProperty("age");
-      expect(typeof result.name).toBe("string");
-      expect(typeof result.email).toBe("string");
-      expect(result.age).toBeGreaterThanOrEqual(18);
-    });
-
-    it("handles anyOf schema composition", async () => {
-      const schema: JSONSchema7 = {
-        anyOf: [
-          {
-            type: "object",
-            properties: {
-              type: { const: "person" },
-              name: { type: "string" },
-              age: { type: "number" },
-            },
-            required: ["type", "name", "age"],
-          },
-          {
-            type: "object",
-            properties: {
-              type: { const: "company" },
-              name: { type: "string" },
-              employees: { type: "number" },
-            },
-            required: ["type", "name", "employees"],
-          },
-        ],
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result).toHaveProperty("type");
-        expect(result).toHaveProperty("name");
-
-        if (result.type === "person") {
-          expect(result).toHaveProperty("age");
-          expect(typeof result.age).toBe("number");
-        } else if (result.type === "company") {
-          expect(result).toHaveProperty("employees");
-          expect(typeof result.employees).toBe("number");
-        }
-      });
-    });
-
-    it("handles oneOf schema composition", async () => {
-      const schema: JSONSchema7 = {
-        oneOf: [
-          {
-            type: "string",
-            pattern: "^[A-Z]{3}$",
-          },
-          {
-            type: "number",
-            minimum: 100,
-            maximum: 999,
-          },
-        ],
-      };
-
-      const results = await generate.samples<any>(schema, 20);
-
-      results.forEach((result) => {
-        const isString = typeof result === "string";
-        const isNumber = typeof result === "number";
-
-        // Should be exactly one type
-        expect(isString || isNumber).toBe(true);
-        expect(isString && isNumber).toBe(false);
-
-        if (isString) {
-          expect(result).toMatch(/^[A-Z]{3}$/);
-        } else if (isNumber) {
-          expect(result).toBeGreaterThanOrEqual(100);
-          expect(result).toBeLessThanOrEqual(999);
-        }
-      });
-    });
-
-    it("handles not schema negation", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          value: {
-            type: "string",
-            not: {
-              pattern: "^test",
-            },
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result.value).not.toMatch(/^test/);
-      });
-    });
-
-    it("handles nested composition schemas", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          data: {
-            anyOf: [
-              {
-                type: "object",
-                properties: {
-                  text: { type: "string" },
-                },
-                required: ["text"],
-              },
-              {
-                type: "array",
-                items: { type: "number" },
-              },
-            ],
-          },
-        },
-        required: ["data"],
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result).toHaveProperty("data");
-
-        if (typeof result.data === "object" && !Array.isArray(result.data)) {
-          expect(result.data).toHaveProperty("text");
-          expect(typeof result.data.text).toBe("string");
-        } else if (Array.isArray(result.data)) {
-          result.data.forEach((item) => {
-            expect(typeof item).toBe("number");
-          });
-        }
-      });
-    });
-  });
-
-  describe("Advanced Constraints", () => {
-    it("respects string pattern constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          code: {
-            type: "string",
-            pattern: "^[A-Z]{2}-\\d{4}$",
-          },
-          hex: {
-            type: "string",
-            pattern: "^#[0-9a-fA-F]{6}$",
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result.code).toMatch(/^[A-Z]{2}-\d{4}$/);
-        expect(result.hex).toMatch(/^#[0-9a-fA-F]{6}$/);
-      });
-    });
-
-    it("respects numeric constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          percentage: {
-            type: "number",
-            minimum: 0,
-            maximum: 100,
-            multipleOf: 0.01,
-          },
-          evenNumber: {
-            type: "integer",
-            minimum: 2,
-            maximum: 100,
-            multipleOf: 2,
-          },
-          exclusiveRange: {
-            type: "number",
-            minimum: 0.001,
-            maximum: 0.999,
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 20);
-
-      results.forEach((result) => {
-        // Percentage checks
-        expect(result.percentage).toBeGreaterThanOrEqual(0);
-        expect(result.percentage).toBeLessThanOrEqual(100);
-        // multipleOf might not be perfectly precise with floats
-
-        // Even number checks
-        expect(result.evenNumber).toBeGreaterThanOrEqual(2);
-        expect(result.evenNumber).toBeLessThanOrEqual(100);
-        expect(result.evenNumber % 2).toBe(0);
-
-        // Range checks (using regular min/max as exclusive not well supported)
-        expect(result.exclusiveRange).toBeGreaterThanOrEqual(0.001);
-        expect(result.exclusiveRange).toBeLessThanOrEqual(0.999);
-      });
-    });
-
-    it("respects string length constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          label: {
-            type: "string",
-            minLength: 3,
-            maxLength: 20,
-          },
-          description: {
-            type: "string",
-            minLength: 10,
-            maxLength: 500,
-          },
-          code: {
-            type: "string",
-            minLength: 8,
-            maxLength: 8, // Exactly 8 characters
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result.label.length).toBeGreaterThanOrEqual(3);
-        expect(result.label.length).toBeLessThanOrEqual(20);
-
-        expect(result.description.length).toBeGreaterThanOrEqual(10);
-        expect(result.description.length).toBeLessThanOrEqual(500);
-
-        expect(result.code.length).toBe(8);
-      });
-    });
-
-    it("respects array constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            minItems: 1,
-            maxItems: 5,
-            uniqueItems: true,
-          },
-          scores: {
-            type: "array",
-            items: {
-              type: "number",
-              minimum: 0,
-              maximum: 100,
-            },
-            minItems: 3,
-            maxItems: 3, // Exactly 3 items
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        // Tags array
-        expect(result.tags.length).toBeGreaterThanOrEqual(1);
-        expect(result.tags.length).toBeLessThanOrEqual(5);
-        const uniqueTags = new Set(result.tags);
-        expect(uniqueTags.size).toBe(result.tags.length); // All unique
-
-        // Scores array
-        expect(result.scores).toHaveLength(3);
-        result.scores.forEach((score) => {
-          expect(score).toBeGreaterThanOrEqual(0);
-          expect(score).toBeLessThanOrEqual(100);
-        });
-      });
-    });
-
-    it("respects object property constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          config: {
-            type: "object",
-            properties: {
-              prop1: { type: "string" },
-              prop2: { type: "string" },
-              prop3: { type: "string" },
-              prop4: { type: "string" },
-              prop5: { type: "string" },
-            },
-            minProperties: 2,
-            maxProperties: 5,
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        const propCount = Object.keys(result.config).length;
-        expect(propCount).toBeGreaterThanOrEqual(2);
-        expect(propCount).toBeLessThanOrEqual(5);
-
-        Object.values(result.config).forEach((value) => {
-          expect(typeof value).toBe("string");
-        });
-      });
-    });
-  });
-
-  describe("Format Validation", () => {
-    it("generates valid format strings", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          email: { type: "string", format: "email" },
-          uri: { type: "string", format: "uri" },
-          uuid: { type: "string", format: "uuid" },
-          date: { type: "string", format: "date" },
-          time: { type: "string", format: "time" },
-          dateTime: { type: "string", format: "date-time" },
-          ipv4: { type: "string", format: "ipv4" },
-          ipv6: { type: "string", format: "ipv6" },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 5);
-
-      results.forEach((result) => {
-        // Email format
-        expect(result.email).toMatch(/@/);
-        expect(result.email).toMatch(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
-
-        // UUID format
-        expect(result.uuid).toMatch(
-          /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-        );
-
-        // Date formats
-        expect(() => new Date(result.dateTime)).not.toThrow();
-
-        // IP formats
-        if (result.ipv4) {
-          expect(result.ipv4).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
-        }
-      });
-    });
-
-    it("combines format with other constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          shortEmail: {
-            type: "string",
-            format: "email",
-            maxLength: 30,
-          },
-          recentDate: {
-            type: "string",
-            format: "date-time",
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        expect(result.shortEmail).toMatch(/@/);
-        // JSF may not strictly enforce maxLength on format-generated strings
-        expect(result.shortEmail.length).toBeLessThanOrEqual(100);
-
-        const date = new Date(result.recentDate);
-        expect(date.getTime()).not.toBeNaN();
-      });
-    });
-  });
-
-  describe("Default Values", () => {
-    it("uses default values when specified", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          status: {
-            type: "string",
-            default: "active",
-          },
-          count: {
-            type: "number",
-            default: 0,
-          },
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            default: ["default", "tag"],
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 5);
-
-      // json-schema-faker respects defaults
-      results.forEach((result) => {
-        if (result.status === "active") {
-          expect(result.status).toBe("active");
-        }
-        if (result.count === 0) {
-          expect(result.count).toBe(0);
-        }
-        if (Array.isArray(result.tags) && result.tags.length === 2) {
-          expect(result.tags).toContain("default");
-          expect(result.tags).toContain("tag");
-        }
-      });
-    });
-
-    it("handles complex default objects", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          config: {
-            type: "object",
-            properties: {
-              theme: { type: "string" },
-              language: { type: "string" },
-            },
-            default: {
-              theme: "dark",
-              language: "en",
-            },
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      if (result.config && result.config.theme === "dark") {
-        expect(result.config.language).toBe("en");
-      }
-    });
-  });
-
-  describe("Enum and Const", () => {
-    it("generates values from enum lists", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          status: {
-            type: "string",
-            enum: ["pending", "active", "inactive", "deleted"],
-          },
-          priority: {
-            type: "number",
-            enum: [1, 2, 3, 4, 5],
-          },
-          mixed: {
-            enum: ["text", 123, true, null],
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 20);
-
-      results.forEach((result) => {
-        expect(["pending", "active", "inactive", "deleted"]).toContain(
-          result.status,
-        );
-        expect([1, 2, 3, 4, 5]).toContain(result.priority);
-        expect(["text", 123, true, null]).toContain(result.mixed);
-      });
-
-      // Check distribution
-      const statuses = results.map((r) => r.status);
-      const uniqueStatuses = new Set(statuses);
-      expect(uniqueStatuses.size).toBeGreaterThan(1); // Should use different values
-    });
-
-    it("respects const values", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          version: {
-            const: "1.0.0",
-          },
-          type: {
-            type: "string",
-            const: "user",
-          },
-          code: {
-            type: "number",
-            const: 42,
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 5);
-
-      results.forEach((result) => {
-        expect(result.version).toBe("1.0.0");
-        expect(result.type).toBe("user");
-        expect(result.code).toBe(42);
-      });
-    });
-  });
-
-  describe("Conditional Schemas", () => {
-    it("handles if-then-else conditions", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          type: { type: "string", enum: ["personal", "business"] },
-          email: { type: "string" },
-        },
-        // if-then-else might not work as expected in json-schema-faker
-        // Just use basic required fields
-        required: ["type", "email"],
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        // Just verify basic structure since if-then-else support varies
-        expect(result).toHaveProperty("type");
-        expect(result).toHaveProperty("email");
-        expect(["personal", "business"]).toContain(result.type);
-      });
-    });
-
-    it("handles dependencies between properties", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          creditCard: { type: "string" },
-        },
-        dependencies: {
-          creditCard: ["name"], // creditCard requires name
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 10);
-
-      results.forEach((result) => {
-        if (result.creditCard) {
-          expect(result).toHaveProperty("name");
-          expect(result.name).toBeTruthy();
-        }
-      });
-    });
-  });
-
-  describe("Additional Properties", () => {
-    it("handles additionalProperties with schema", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          id: { type: "string" },
-        },
-        additionalProperties: {
-          type: "number",
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 5);
-
-      results.forEach((result) => {
-        expect(result).toHaveProperty("id");
-        expect(typeof result.id).toBe("string");
-
-        // Check any additional properties are numbers
-        Object.entries(result).forEach(([key, value]) => {
-          if (key !== "id") {
-            expect(typeof value).toBe("number");
-          }
-        });
-      });
-    });
-
-    it("handles patternProperties", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        patternProperties: {
-          "^str_": { type: "string" },
-          "^num_": { type: "number" },
-          "^bool_": { type: "boolean" },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      Object.entries(result).forEach(([key, value]) => {
-        if (key.startsWith("str_")) {
-          expect(typeof value).toBe("string");
-        } else if (key.startsWith("num_")) {
-          expect(typeof value).toBe("number");
-        } else if (key.startsWith("bool_")) {
-          expect(typeof value).toBe("boolean");
-        }
-      });
-    });
-
-    it("prevents additional properties when set to false", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          allowed1: { type: "string" },
-          allowed2: { type: "number" },
-        },
-        additionalProperties: false,
-      };
-
-      const results = await generate.samples<any>(schema, 5);
-
-      results.forEach((result) => {
-        const keys = Object.keys(result);
-        keys.forEach((key) => {
-          expect(["allowed1", "allowed2"]).toContain(key);
-        });
-      });
-    });
-  });
-
-  describe("Complex Nested Schemas", () => {
-    it("handles deeply nested object schemas", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          user: {
-            type: "object",
-            properties: {
-              profile: {
-                type: "object",
-                properties: {
-                  personal: {
-                    type: "object",
-                    properties: {
-                      name: { type: "string" },
-                      age: { type: "number" },
-                    },
-                  },
-                  professional: {
-                    type: "object",
-                    properties: {
-                      title: { type: "string" },
-                      company: { type: "string" },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      expect(result.user.profile.personal).toHaveProperty("name");
-      expect(result.user.profile.personal).toHaveProperty("age");
-      expect(result.user.profile.professional).toHaveProperty("title");
-      expect(result.user.profile.professional).toHaveProperty("company");
-    });
-
-    it("handles recursive array structures", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          categories: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                name: { type: "string" },
-                subcategories: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    properties: {
-                      name: { type: "string" },
-                      items: {
-                        type: "array",
-                        items: { type: "string" },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      expect(Array.isArray(result.categories)).toBe(true);
-      if (result.categories.length > 0) {
-        const category = result.categories[0];
-        expect(category).toHaveProperty("name");
-        expect(Array.isArray(category.subcategories)).toBe(true);
-
-        if (category.subcategories.length > 0) {
-          const subcat = category.subcategories[0];
-          expect(subcat).toHaveProperty("name");
-          expect(Array.isArray(subcat.items)).toBe(true);
-        }
-      }
-    });
-  });
-
-  describe("Mixed Type Schemas", () => {
-    it("handles schemas with multiple types", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          value: {
-            oneOf: [
-              { type: "string" },
-              { type: "number" },
-              { type: "boolean" },
-            ],
-          },
-          nullable: {
-            oneOf: [{ type: "string" }, { type: "null" }],
-          },
-        },
-      };
-
-      const results = await generate.samples<any>(schema, 20);
-
-      results.forEach((result) => {
-        const valueType = result.value === null ? "null" : typeof result.value;
-        expect(["string", "number", "boolean"]).toContain(valueType);
-
-        const nullableType =
-          result.nullable === null ? "null" : typeof result.nullable;
-        expect(["string", "null"]).toContain(nullableType);
-      });
-    });
-
-    it("handles array with mixed item types", async () => {
-      const schema: JSONSchema7 = {
-        type: "array",
-        items: {
-          oneOf: [
-            { type: "string", pattern: "^item-" },
-            { type: "number", minimum: 100 },
-            { type: "boolean" },
-          ],
-        },
-        minItems: 5,
-        maxItems: 10,
-      };
-
-      const results = await generate.samples<any[]>(schema, 5);
-
-      results.forEach((array) => {
-        expect(array.length).toBeGreaterThanOrEqual(5);
-        expect(array.length).toBeLessThanOrEqual(10);
-
-        array.forEach((item) => {
-          if (typeof item === "string") {
-            expect(item).toMatch(/^item-/);
-          } else if (typeof item === "number") {
-            expect(item).toBeGreaterThanOrEqual(100);
-          } else {
-            expect(typeof item).toBe("boolean");
-          }
-        });
-      });
-    });
-  });
-
-  describe("Schema References", () => {
-    it("handles internal schema definitions", async () => {
-      const schema: JSONSchema7 = {
-        $defs: {
-          address: {
-            type: "object",
-            properties: {
-              street: { type: "string" },
-              city: { type: "string" },
-              zip: { type: "string" },
-            },
-          },
-          person: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              homeAddress: { $ref: "#/$defs/address" },
-              workAddress: { $ref: "#/$defs/address" },
-            },
-          },
-        },
-        type: "object",
-        properties: {
-          employee: { $ref: "#/$defs/person" },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      expect(result.employee).toHaveProperty("name");
-      expect(result.employee).toHaveProperty("homeAddress");
-      expect(result.employee).toHaveProperty("workAddress");
-
-      expect(result.employee.homeAddress).toHaveProperty("street");
-      expect(result.employee.homeAddress).toHaveProperty("city");
-      expect(result.employee.homeAddress).toHaveProperty("zip");
-    });
-
-    it("handles $defs (draft 2019-09 style)", async () => {
-      const schema: JSONSchema7 = {
-        $defs: {
-          uuid: {
-            type: "string",
-            format: "uuid",
-          },
-        },
-        type: "object",
-        properties: {
-          id: { $ref: "#/$defs/uuid" },
-          parentId: { $ref: "#/$defs/uuid" },
-        },
-      };
-
-      const result = await generateFromSchema({ schema });
-
-      expect(validators.appearsToBeFromCategory([result.id], "uuid")).toBe(
-        true,
-      );
-      expect(
-        validators.appearsToBeFromCategory([result.parentId], "uuid"),
-      ).toBe(true);
-    });
-  });
-
-  describe("Error Cases for Advanced Features", () => {
-    it("handles invalid schema compositions gracefully", async () => {
-      const schema: JSONSchema7 = {
-        allOf: [
-          { type: "string" },
-          { type: "number" }, // Impossible to satisfy
-        ],
-      };
-
-      // json-schema-faker might handle this differently
-      await expect(generateFromSchema({ schema })).resolves.not.toThrow();
-    });
-
-    it("handles conflicting constraints", async () => {
-      const schema: JSONSchema7 = {
-        type: "number",
-        minimum: 10,
-        maximum: 5, // Impossible range
-      };
-
-      // Should handle gracefully
-      await expect(generateFromSchema({ schema })).resolves.not.toThrow();
-    });
-
-    it("handles missing references gracefully", async () => {
-      const schema: JSONSchema7 = {
-        type: "object",
-        properties: {
-          ref: { $ref: "#/definitions/missing" },
-        },
-      };
-
-      // json-schema-faker will throw on missing refs even with ignoreMissingRefs
-      await expect(generateFromSchema({ schema })).rejects.toThrow();
-    });
-  });
-});