Logo
Overview

ИИ для генерации тестовых данных и моков API: промпты и примеры

November 18, 2026
5 min read

ИИ для генерации тестовых данных и моков API: промпты и примеры

Когда работаешь с двумя-тремя сущностями — проблем нет. Но стоит системе перевалить за десяток таблиц с внешними ключами и связями «многие-ко-многим», как ручная набивка тестовых данных превращается в отдельный проект. Разработчик ждёт осмысленных примеров. Аналитик ждёт доступ к реальной БД, а его нет. Тесты гоняют на «Тест», «Тест2» и «qwerty».

LLM заходит в эту проблему как нож в масло. Шаблонная генерация — её родная среда. Вы описываете структуру данных, она выдаёт сотни осмысленных записей. А если скормить ей OpenAPI-спек — получите ещё и живой мок-сервер. Не «заглушку с hello world», а сервер с валидными данными, который отвечает на запросы как настоящий бэкенд.

Зачем это вообще нужно

Ручная генерация тестовых данных съедает часы. И ладно бы один раз — данные нужны всем: разработчику для отладки, тестировщику для кейсов, демонстрации заказчику. А когда схема меняется (спойлер: она меняется всегда), всё начинается заново.

LLM справляется с этим по трём причинам:

Первая — скорость. Вы описываете сущность на естественном языке, модель генерирует 50–200 записей за один запрос. Неидеальных, но осмысленных. Дальше — дошлифовка. Ручной труд сокращается с часов до минут.

Вторая — разнообразие. Человек склонен к шаблонам. Я ловил себя на том, что все мои «тестовые пользователи» — это Иван Иванов, Пётр Петров и Сидоров Сидор. LLM генерирует по-настоящему разные данные: имена, email-ы, суммы, даты — без повторов.

Третья — граничные случаи. Модель легко добавляет пустые строки, null, отрицательные числа, строки в 10 000 символов. То, что аналитик может забыть, LLM выдаёт по запросу систематически.

Но это не серебряная пуля. Модель не понимает бизнес-логику вашей системы. Она может сгенерировать «заказ на минус 500 рублей» или «пользователя 2025 года рождения с email-ом 1990 года». Валидация всё ещё на вас.

Как это работает: пайплайн генерации

100%
graph TD
  A["Требования / OpenAPI-спек"] --> B["LLM: анализ структуры данных"]
  B --> C["Генерация схемы: поля, типы, связи"]
  C --> D["Позитивные значения: реалистичные данные"]
  C --> E["Граничные значения: min/max, пустые строки, null"]
  C --> F["Негативные значения: невалидный email, нарушение связей"]
  D --> G["Валидация консистентности"]
  E --> G
  F --> G
  G --> H["Экспорт: JSON, SQL, CSV"]
  G --> I["Мок-сервер: Prism, WireMock, json-server"]
  style A fill:#4a90d9,stroke:#2c5f8a,color:#fff
  style B fill:#7b68ee,stroke:#5a4db2,color:#fff
  style C fill:#f0a500,stroke:#c88400,color:#fff
  style D fill:#50c878,stroke:#3a9a5c,color:#fff
  style E fill:#50c878,stroke:#3a9a5c,color:#fff
  style F fill:#50c878,stroke:#3a9a5c,color:#fff
  style G fill:#e0e0e0,stroke:#999,color:#333
  style H fill:#4a90d9,stroke:#2c5f8a,color:#fff
  style I fill:#4a90d9,stroke:#2c5f8a,color:#fff

Пайплайн завязан на трёх ветках генерации значений: позитивные, граничные и негативные. Все три потока сходятся в валидацию — она проверяет консистентность связей, уникальность ID и соответствие типов. После валидации данные уходят либо на экспорт в нужный формат, либо прямиком в конфигурацию мок-сервера.

Ветки не зря разделены. На практике позитивные данные нужны для демо и дымовых тестов. Граничные — для тестирования валидации. Негативные — для проверки обработки ошибок. LLM выдаёт их отдельными запросами, потому что в одном прогоне модель начинает путать сценарии и смешивать корректные данные с мусором.

Промпты для генерации тестовых данных

Промпты — это не «напиши мне данные». Это инженерная задача. Чем точнее спецификация на входе, тем качественнее результат на выходе. Я разбил промпты на три уровня сложности.

Базовый: генерация из описания сущности

Подходит, когда нужно быстро накидать данных для одной-двух таблиц. Описываем поля, типы, ограничения — и модель выдаёт JSON или SQL.

Промпт:

Ты — генератор тестовых данных для backend-системы. Сгенерируй 20 записей
для сущности «Пользователь» (users) в формате JSON.
Поля:
- id: UUID v4, уникальный
- first_name: русское имя, строка 2–20 символов
- last_name: русская фамилия, строка 2–30 символов
- email: валидный email в домене @example.com, уникальный
- phone: российский мобильный номер в формате +7 (XXX) XXX-XX-XX
- role: одно из ["admin", "manager", "user", "readonly"]
- created_at: дата в ISO 8601 за последние 30 дней
Ограничения:
- 60% записей — роль "user"
- 20% — "manager"
- 10% — "admin"
- 10% — "readonly"
- У 5% пользователей номер телефона отсутствует (null)
Формат вывода: JSON-массив из 20 объектов.
Выведи только JSON, без комментариев.

Модель выдаст массив объектов. Дальше — копируете в файл, подставляете в SQL-скрипт или импортируете напрямую. На проверку уходит пара минут: пробежаться глазами по email-ам, убедиться, что распределение ролей примерно совпадает с заданным.

На деле первая итерация почти всегда требует правок. То модель выдала не те кавычки, то phone не в том формате. Это нормально — подкручиваете промпт и перезапускаете. Третий-четвёртый запрос обычно уже чистый.

Продвинутый: граничные и негативные кейсы

Когда данные нужны для тестирования валидации, базового промпта мало. Я дополняю инструкцию явным списком ошибок, которые модель должна внедрить.

Промпт:

Сгенерируй 30 записей для сущности «Заказ» (orders) в JSON.
Поля и правила валидации:
- id: UUID v4
- user_id: UUID, ссылка на users.id
- amount: decimal(10,2), должен быть > 0 и < 1 000 000
- currency: строго "RUB", "USD" или "EUR"
- status: "new" | "processing" | "completed" | "cancelled"
- items_count: целое от 1 до 100
- delivery_address: строка 5–200 символов, не может быть пустой
- created_at: ISO 8601
Разбей вывод на три блока:
Блок 1 — Валидные данные (15 записей): все поля в допустимых диапазонах.
Блок 2 — Граничные значения (10 записей):
- amount = 0.01 (минимальный)
- amount = 999999.99 (максимальный)
- items_count = 1
- items_count = 100
- delivery_address = ровно 5 символов
- delivery_address = ровно 200 символов
- created_at = 30 дней назад
- created_at = текущая дата и время с точностью до секунд
Блок 3 — Негативные данные (5 записей):
- amount = 0
- amount = -500
- amount = 1000000
- items_count = 0
- items_count = 101
- currency = "GBP" (неподдерживаемая)
- delivery_address = "" (пустая строка)
- status = "shipped" (недопустимый статус)
Для каждого блока выведи JSON-массив. Добавь комментарий-заголовок перед каждым блоком.

От такого промпта модель выдаёт структурированный результат. Блок 3 особенно полезен: он сразу показывает, какие поля сломаются при невалидном вводе.

Связные данные: foreign key и зависимости

Самое интересное начинается, когда сущностей несколько и они связаны. Тут нужна двухпроходная стратегия.

Шаг 1 — генерируем родительские сущности (пользователи, категории). Шаг 2 — передаём их LLM как контекст и просим сгенерировать дочерние (заказы, товары в заказе) с реальными ID из шага 1.

Промпт для шага 2:

Ниже — 10 пользователей в формате JSON. Сгенерируй 30 заказов,
равномерно распределённых между этими пользователями (примерно по 3 на каждого).
Пользователи:
[вставляете JSON из шага 1]
Заказ (orders):
- id: UUID v4
- user_id: UUID из списка выше
- amount: от 100 до 50 000
- status: распределение — 50% "completed", 30% "processing", 10% "new", 10% "cancelled"
- created_at: в пределах последних 90 дней
У заказов со статусом "completed" поле created_at должно быть старше 7 дней.
У "new" — не старше 24 часов.
Формат: JSON-массив.

Модель подхватывает реальные user_id, следит за распределением статусов и временными ограничениями. С первого раза может не попасть в проценты — тогда добавляете фразу «перегенерируй, точно соблюдая распределение». Обычно хватает двух итераций.

Генерация моков API

Отдельная магия — когда LLM не просто генерирует данные, а заворачивает их в рабочий мок-сервер. На вход подаётся OpenAPI-спецификация, на выходе — конфигурация для Prism, WireMock или json-server.

Допустим, у вас есть openapi.yaml с описанием эндпоинтов GET /users, POST /orders и т.д. Вы загружаете его в LLM и просите сконфигурировать мок-сервер с реалистичными ответами.

Промпт:

Ниже — фрагмент OpenAPI 3.0 спецификации. На основе него создай конфигурацию
для json-server (файл db.json) с тестовыми данными.
Спецификация:
[вставляете openapi.yaml]
Требования к данным:
- 15 пользователей (users) с разными ролями
- 50 заказов (orders), привязанных к реальным user_id
- У каждого пользователя от 1 до 7 заказов
- Заказы за последние 90 дней
- Суммы заказов — от 500 до 100 000 руб.
- У 10% заказов статус "cancelled"
- У 5% пользователей нет заказов
Сгенерируй полный db.json, готовый к запуску json-server.
Все id должны быть уникальны и консистентны между коллекциями.

На выходе — файл, который можно скормить json-server и получить работающее API за минуту. Не продакшен, но для прототипа или тестового стенда — более чем.

С генерацией OpenAPI-спеков, кстати, LLM тоже справляется — об этом был отдельный разбор.

Типичные ошибки LLM и как их ловить

Модель ошибается предсказуемо. Я выделил пять повторяющихся паттернов:

1. Неуникальные ID. Модель копирует один и тот же UUID на несколько записей. Лечится явной инструкцией: «каждый id должен быть уникальным UUID v4». Если не помогает — добавьте «проверь, что в выводе нет повторяющихся id».

2. Нарушение внешних ключей. Ссылки на несуществующие user_id и product_id. Решение — двухпроходная стратегия, которую я описал выше. Сначала родители, потом дети с реальными ID в контексте.

3. Однотипность данных. Все суммы — круглые. Все email-ы — user123@example.com. Все даты — первое число месяца. Лечится требованием: «варьируй значения, избегай шаблонов, используй разные форматы в пределах допустимых».

4. Игнорирование распределений. Просите 60% completed — получаете 100%. Модель склонна к «безопасному» выбору. В промпте помогает фраза «строго соблюдай указанное распределение, подсчитай количество записей каждого типа перед выводом».

5. Выход за границы. amount: -500 там, где просили > 0. Или role: "superadmin", которого нет в списке. Лечится добавлением в промпт блока «Запрещено» с явным перечислением недопустимых значений.

Чем сложнее структура данных, тем чаще модель срезает углы. Двухпроходная стратегия и явные запреты в промпте закрывают 90% проблем.

Интеграция в рабочий процесс

Генерация через ChatGPT в браузере — это уровень «попробовал, понравилось». Для системной работы нужна связка с инструментами.

Сценарий 1: ручная генерация. Копируете спецификацию, вставляете в ChatGPT/Claude, получаете JSON, сохраняете в файл. Подходит для разовых задач. Минус — контекст ограничен, большие схемы не влезают.

Сценарий 2: скрипт на Python + API. Пишете скрипт, который читает OpenAPI-спек локально, отправляет промпт через API к LLM и пишет результат в db.json или SQL-файл. Оборачиваете в Makefile или npm run generate-data. Разработчики обновляют данные одной командой после изменения схемы. Я использую именно этот подход на проектах с частыми миграциями.

Сценарий 3: CI/CD-пайплайн. При каждом пуше в репозиторий со спецификацией триггерится генерация тестовых данных и деплой мок-сервера. Фронтендеры всегда имеют актуальный стенд, не дожидаясь бэкенда. Риск — LLM может выдать битые данные и уронить стенд. Обязателен шаг валидации: схема должна проходить JSON Schema-проверку до деплоя.

Связка с генерацией тест-кейсов — мощное комбо. Данные и кейсы генерируются из одной спецификации: разбирал этот подход отдельно.

Главный вывод

LLM не заменит осмысленное тестирование. Но рутину — генерацию сотен записей, подстановку связей, форматирование под нужный экспорт — она снимает почти полностью. Час ручной работы превращается в 10 минут промпт-инжиниринга и 5 минут валидации.

С моками API та же история. OpenAPI-спек есть почти на каждом проекте. Скормить его LLM и получить работающий json-server — дело одного промпта. Фронтендеры раньше начинают интеграцию, тестировщики — проверку. Бэкенд перестаёт быть бутылочным горлышком.

Два правила, которые я вывел для себя: всегда используйте двухпроходную стратегию для связных данных и всегда добавляйте блок «Запрещено» в промпт для негативных кейсов. Экономит по две-три итерации на каждом запуске.