Synthetic Test Data Generation and Edge-Case Fuzzing

Ограничение Faker:      [Случайное имя] + [Случайный возраст] (нет скрытых связей и семантики)
Реальный трафик:        [Коррелированные поля] + [Аномальные граничные случаи] + [Power Law объемов]
Frontier-LLM Генератор: [Контролируемый закон распределения] + [Генеративный мутационный фаззинг]

┌────────────────────────────────────────────────────────┐
│ 1. Конфигурация схемы (Zod Schema / Domain Invariants) │
└──────────────────────────┬─────────────────────────────┘
                           │
                           ▼
┌────────────────────────────────────────────────────────┐
│ 2. Frontier-LLM: Синтез семантического ядра            │
│    - Соблюдение Power Law распределений                │
│    - Реалистичные корреляции параметров                │
└──────────────────────────┬─────────────────────────────┘
                           │ Валидный сырой DTO
                           ▼
┌────────────────────────────────────────────────────────┐
│ 3. Adversarial Mutator (Мутационный фаззер)            │
│    - Внедрение поврежденного UTF-8 / BiDi              │
│    - Граничные значения чисел (MaxSafeInt + 1)         │
│    - Аномалии временных зон и Leap Seconds             │
│    - Конфликты ключей идемпотентности                  │
└──────────────────────────┬─────────────────────────────┘
                           │ Мутированный Payload
                           ▼
┌────────────────────────────────────────────────────────┐
│ 4. Deterministic Invariant Gate                        │
│    - Проверка схемы (Fail-fast при синтаксическом сломе)│
│    - Разметка ожидаемого статуса (Expected: 422 / 500) │
└──────────────────────────┬─────────────────────────────┘
                           │
                           ▼
┌────────────────────────────────────────────────────────┐
│ 5. Целевой датасет: JSONL / Parquet для CI-тестов      │
└────────────────────────────────────────────────────────┘

import { z } from "zod";
import OpenAI from "openai";

// Базовая схема финансовой транзакции
export const TransactionSchema = z.object({
  id: z.string().uuid(),
  userId: z.string().min(5),
  amount: z.number().positive(),
  currency: z.enum(["USD", "EUR", "GBP", "JPY", "KWD"]),
  timestamp: z.string().datetime(),
  idempotencyKey: z.string().min(16),
  metadata: z.record(z.string(), z.string()).default({}),
});

export type Transaction = z.infer<typeof TransactionSchema>;

export interface SyntheticBatchOptions {
  batchSize: number;
  mutationRate: number; // Вероятность инжекции граничного кейса (0.0 - 1.0)
  targetDistribution: "power_law" | "uniform";
}

export interface SyntheticRecord {
  data: unknown;
  isAdversarial: boolean;
  edgeCaseType?: "timezone_anomaly" | "utf8_malformed" | "float_overflow" | "race_condition";
  expectedValidationResult: "valid" | "invalid_schema" | "semantic_error";
}

export class SyntheticDatasetEngine {
  private openai: OpenAI;

  constructor(apiKey?: string) {
    this.openai = new OpenAI({ apiKey: apiKey ?? process.env.OPENAI_API_KEY });
  }

  /**
   * Генерация семантического ядра с помощью LLM Structured Outputs
   */
  public async generateSeedBatch(options: SyntheticBatchOptions): Promise<Transaction[]> {
    const systemPrompt = `
Вы — генератор тестовых данных для ядра банковского биллинга.
Сгенерируйте массив из ${options.batchSize} транзакций.
Распределение сумм (amount): ${options.targetDistribution === "power_law" ? "Power-law (Pareto alpha=1.5), 80% транзакций от 1.00 до 50.00, 15% до 500.00, 5% свыше 10000.00" : "Равномерное"}.
Все даты должны быть в формате ISO 8601 UTC.
`;

    const response = await this.openai.chat.completions.create({
      model: "gpt-4o-mini",
      temperature: 0.7,
      response_format: {
        type: "json_schema",
        json_schema: {
          name: "transaction_batch",
          schema: {
            type: "object",
            properties: {
              transactions: {
                type: "array",
                items: {
                  type: "object",
                  properties: {
                    id: { type: "string" },
                    userId: { type: "string" },
                    amount: { type: "number" },
                    currency: { type: "string", enum: ["USD", "EUR", "GBP", "JPY", "KWD"] },
                    timestamp: { type: "string" },
                    idempotencyKey: { type: "string" },
                    metadata: { type: "object", additionalProperties: { type: "string" } },
                  },
                  required: ["id", "userId", "amount", "currency", "timestamp", "idempotencyKey", "metadata"],
                  additionalProperties: false,
                },
              },
            },
            required: ["transactions"],
            additionalProperties: false,
          },
          strict: true,
        },
      },
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: `Сгенерируй батч транзакций. Размер: ${options.batchSize}` },
      ],
    });

    const content = response.choices[0]?.message.content;
    if (!content) {
      throw new Error("Пустой ответ от модели при генерации сид-батча.");
    }

    const parsed = JSON.parse(content) as { transactions: Transaction[] };
    return parsed.transactions;
  }

  /**
   * Мутационный фаззер: инжекция деструктивных граничных случаев
   */
  public applyAdversarialMutations(
    seeds: Transaction[],
    mutationRate: number
  ): SyntheticRecord[] {
    const results: SyntheticRecord[] = [];

    for (const seed of seeds) {
      const shouldMutate = Math.random() < mutationRate;

      if (!shouldMutate) {
        results.push({
          data: seed,
          isAdversarial: false,
          expectedValidationResult: "valid",
        });
        continue;
      }

      // Выбор типа мутации
      const mutationType = this.selectMutationType();
      const mutated = this.injectEdgeCase(seed, mutationType);

      results.push(mutated);
    }

    return results;
  }

  private selectMutationType(): NonNullable<SyntheticRecord["edgeCaseType"]> {
    const types: NonNullable<SyntheticRecord["edgeCaseType"]>[] = [
      "timezone_anomaly",
      "utf8_malformed",
      "float_overflow",
      "race_condition",
    ];
    const randomIndex = Math.floor(Math.random() * types.length);
    return types[randomIndex];
  }

  private injectEdgeCase(
    base: Transaction,
    mutationType: NonNullable<SyntheticRecord["edgeCaseType"]>
  ): SyntheticRecord {
    const copy = structuredClone(base) as Record<string, unknown>;

    switch (mutationType) {
      case "timezone_anomaly":
        // Неоднозначное декретное время или экстремальный сдвиг часового пояса
        copy.timestamp = "2026-03-29T02:30:00+14:00"; // Смещение +14:00 (остров Лайн)
        return {
          data: copy,
          isAdversarial: true,
          edgeCaseType: "timezone_anomaly",
          expectedValidationResult: "valid", // Должно корректно парситься в UTC
        };

      case "utf8_malformed":
        // BiDi Override и Zero-Width Joiner в метаданных
        copy.metadata = {
          note: "Standard payment \u202E\u0000\uFEFFPAYMENT_REDIRECT_INJECT",
          userComment: "\uD83D\uDE00\u200D\uD83D\uDE80".repeat(50),
        };
        return {
          data: copy,
          isAdversarial: true,
          edgeCaseType: "utf8_malformed",
          expectedValidationResult: "valid", // Санитайзер обязан обработать без исключений
        };

      case "float_overflow":
        // Превышение точности IEEE 754 float64 (Number.MAX_SAFE_INTEGER + 3)
        copy.amount = 9007199254740993.45;
        return {
          data: copy,
          isAdversarial: true,
          edgeCaseType: "float_overflow",
          expectedValidationResult: "semantic_error", // Биллинг должен отклонить неточное число
        };

      case "race_condition":
        // Дубликат ключа идемпотентности с измененной суммой для проверки ACID
        copy.idempotencyKey = "IDEMP_LOCKED_SHARED_KEY_12345";
        copy.amount = 0.0000001; // Субнормальная величина
        return {
          data: copy,
          isAdversarial: true,
          edgeCaseType: "race_condition",
          expectedValidationResult: "semantic_error",
        };
    }
  }
}

import { describe, it, expect } from "vitest";
import { SyntheticDatasetEngine, TransactionSchema } from "@/lib/synthetic/dataset-generator";

describe("Конвейер генерации синтетических данных и фаззинга", () => {
  const engine = new SyntheticDatasetEngine();

  it("генерирует валидную выборку с соблюдением контрактов Zod", async () => {
    const seeds = await engine.generateSeedBatch({
      batchSize: 5,
      mutationRate: 0.0,
      targetDistribution: "power_law",
    });

    expect(seeds).toHaveLength(5);
    for (const record of seeds) {
      const parsed = TransactionSchema.safeParse(record);
      expect(parsed.success).toBe(true);
    }
  });

  it("корректно классифицирует мутационные аномалии", async () => {
    const seeds = await engine.generateSeedBatch({
      batchSize: 10,
      mutationRate: 0.0,
      targetDistribution: "uniform",
    });

    const dataset = engine.applyAdversarialMutations(seeds, 0.5);
    const adversarialRecords = dataset.filter((r) => r.isAdversarial);

    expect(adversarialRecords.length).toBeGreaterThan(0);

    for (const item of adversarialRecords) {
      if (item.edgeCaseType === "float_overflow") {
        const rawAmount = (item.data as { amount: number }).amount;
        expect(rawAmount).toBeGreaterThan(Number.MAX_SAFE_INTEGER);
      }
    }
  });
});