Release Fixture Tools 0.1.0

2026-09-01 13:03:32 +02:00
commit f5d018c64f
57 changed files with 9981 additions and 0 deletions
@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import {
+  generateFixtures,
+  modelJson,
+  parseFixtureModel,
+  serializeDataset,
+  type GeneratedDataset,
+} from "../../src/fixture/model";
+
+const SQL = `CREATE TABLE users (
+  id INTEGER PRIMARY KEY,
+  email VARCHAR(80) NOT NULL UNIQUE,
+  score DECIMAL(5,2)
+);
+CREATE TABLE orders (
+  id INTEGER PRIMARY KEY,
+  user_id INTEGER NOT NULL REFERENCES users(id)
+);`;
+
+describe("fixture model", () => {
+  it("imports focused SQL constraints and preserves foreign keys", () => {
+    const parsed = parseFixtureModel(SQL, "sql");
+    expect(parsed.model.tables).toHaveLength(2);
+    expect(parsed.model.tables[0]?.fields[0]).toMatchObject({
+      name: "id",
+      type: "integer",
+      required: true,
+      unique: true,
+      distribution: "sequential",
+    });
+    expect(parsed.model.tables[0]?.fields[1]).toMatchObject({
+      name: "email",
+      type: "email",
+      unique: true,
+      maxLength: 80,
+    });
+    expect(parsed.model.tables[1]?.fields[1]).toMatchObject({
+      type: "foreignKey",
+      reference: "users.id",
+    });
+  });
+
+  it("generates replayable records with referential integrity", () => {
+    const model = parseFixtureModel(SQL, "sql").model;
+    const options = {
+      seed: "repeat-me",
+      rows: 20,
+      boundaryPercent: 15,
+      invalidPercent: 0,
+    };
+    const first = generateFixtures(model, options);
+    const second = generateFixtures(model, options);
+    expect(first).toEqual(second);
+    expect(
+      generateFixtures(model, { ...options, seed: "different" }),
+    ).not.toEqual(first);
+    const ids = new Set(first.tables.users?.map((row) => row.id));
+    expect(first.tables.orders?.every((row) => ids.has(row.user_id))).toBe(
+      true,
+    );
+    expect(new Set(first.tables.users?.map((row) => row.email)).size).toBe(20);
+  });
+
+  it("imports JSON Schema bounds and round-trips the editable model", () => {
+    const parsed = parseFixtureModel(
+      JSON.stringify({
+        title: "People",
+        type: "object",
+        required: ["age"],
+        properties: {
+          age: { type: "integer", minimum: 18, maximum: 90 },
+          state: { enum: ["draft", "active"] },
+          nickname: { type: "string", minLength: 2, maxLength: 8 },
+        },
+      }),
+      "json-schema",
+    );
+    expect(parsed.model.tables[0]).toMatchObject({ name: "People" });
+    expect(parsed.model.tables[0]?.fields[0]).toMatchObject({
+      minimum: 18,
+      maximum: 90,
+      required: true,
+    });
+    expect(
+      parseFixtureModel(modelJson(parsed.model), "fixture-model").model,
+    ).toEqual(parsed.model);
+  });
+
+  it("records every intentional mutation and emits common formats", () => {
+    const model = parseFixtureModel("id,email\n", "csv").model;
+    const dataset = generateFixtures(model, {
+      seed: "invalid",
+      rows: 3,
+      boundaryPercent: 0,
+      invalidPercent: 100,
+    });
+    expect(dataset.violations).toHaveLength(6);
+    expect(serializeDataset(dataset, "json")).toMatch(/^\[/u);
+    expect(serializeDataset(dataset, "ndjson").trim().split("\n")).toHaveLength(
+      3,
+    );
+    expect(serializeDataset(dataset, "xml")).toContain("<fixtures");
+    expect(serializeDataset(dataset, "sql")).toContain('INSERT INTO "records"');
+  });
+
+  it("makes CSV spreadsheet-safe and quotes SQL literals", () => {
+    const dataset: GeneratedDataset = {
+      seed: "safe",
+      rowsPerTable: 1,
+      tables: {
+        records: [{ value: '=HYPERLINK("https://invalid")', quote: "O'Brien" }],
+      },
+      violations: [],
+    };
+    expect(serializeDataset(dataset, "csv")).toContain("'=HYPERLINK");
+    expect(serializeDataset(dataset, "sql")).toContain("O''Brien");
+  });
+
+  it("imports bounded XSD and rejects active document declarations", () => {
+    const xsd = `<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="people"><xs:complexType><xs:sequence><xs:element name="age" type="xs:integer"/><xs:element name="email" type="xs:string" minOccurs="0"/></xs:sequence></xs:complexType></xs:element></xs:schema>`;
+    const parsed = parseFixtureModel(xsd, "xsd");
+    expect(parsed.model.tables[0]?.fields).toMatchObject([
+      { name: "age", type: "integer", required: true },
+      { name: "email", required: false },
+    ]);
+    expect(() =>
+      parseFixtureModel('<!DOCTYPE x [<!ENTITY y "z">]><x/>', "xsd"),
+    ).toThrow(/DOCTYPE/u);
+  });
+
+  it("rejects misleading recipes and caps wide generations", () => {
+    expect(() =>
+      parseFixtureModel(
+        JSON.stringify({
+          tables: [
+            {
+              name: "records",
+              fields: [
+                {
+                  name: "id",
+                  type: "integer",
+                  required: true,
+                  unique: true,
+                  distribution: "constant",
+                  constant: "wrong type",
+                },
+              ],
+            },
+          ],
+        }),
+        "fixture-model",
+      ),
+    ).toThrow(/constant/u);
+
+    const wide = {
+      tables: [
+        {
+          name: "wide",
+          fields: Array.from({ length: 100 }, (_unused, index) => ({
+            name: `field_${index}`,
+            type: "string" as const,
+            required: true,
+            unique: false,
+            distribution: "sequential" as const,
+          })),
+        },
+      ],
+    };
+    expect(() =>
+      generateFixtures(wide, {
+        seed: "bounded",
+        rows: 1_001,
+        boundaryPercent: 0,
+        invalidPercent: 0,
+      }),
+    ).toThrow(/100,000 field values/u);
+  });
+});