NLP для Конвертации Требований в Тесты: От User Story к Автоматизированному BDD

# Используя spaCy для извлечения сущностей
import spacy

nlp = spacy.load("ru_core_news_lg")
doc = nlp(user_story_text)

# Извлечь сущности
entities = {
    "АКТЁР": [],        # зарегистрированный пользователь
    "ДЕЙСТВИЕ": [],     # сбросить, отправить, кликнуть, установить
    "ОБЪЕКТ": [],       # пароль, email, ссылка
    "ОГРАНИЧЕНИЕ": [],  # 24 часа, мин 8 символов, 1 заглавная, 1 цифра
    "СИСТЕМА": []       # страница сброса, email-система
}

for ent in doc.ents:
    if ent.label_ == "PER":
        entities["АКТЁР"].append(ent.text)
    elif ent.label_ in ["TIME", "DATE", "QUANTITY"]:
        entities["ОГРАНИЧЕНИЕ"].append(ent.text)

# Вывод:
{
  "АКТЁР": ["зарегистрированный пользователь"],
  "ДЕЙСТВИЕ": ["сбросить", "отправить", "кликнуть", "установить"],
  "ОБЪЕКТ": ["пароль", "email-адрес", "ссылка сброса", "новый пароль"],
  "ОГРАНИЧЕНИЕ": ["24 часа", "мин 8 символов", "1 заглавная", "1 цифра"],
  "СИСТЕМА": ["страница сброса", "Система"]
}

# Установить spaCy с трансформерной моделью
pip install spacy transformers
python -m spacy download ru_core_news_lg

# Загрузить модель
import spacy
nlp = spacy.load("ru_core_news_lg")

# Добавить кастомный распознаватель сущностей для доменных терминов
from spacy.pipeline import EntityRuler

ruler = nlp.add_pipe("entity_ruler", before="ner")
patterns = [
    {"label": "UI_ЭЛЕМЕНТ", "pattern": [{"LOWER": "кнопка"}]},
    {"label": "UI_ЭЛЕМЕНТ", "pattern": [{"LOWER": "форма"}]},
    {"label": "UI_ЭЛЕМЕНТ", "pattern": [{"LOWER": "страница"}]},
    {"label": "ДЕЙСТВИЕ", "pattern": [{"LOWER": "клик"}]},
    {"label": "ДЕЙСТВИЕ", "pattern": [{"LOWER": "ввести"}]},
    {"label": "ДЕЙСТВИЕ", "pattern": [{"LOWER": "отправить"}]},
    {"label": "ВАЛИДАЦИЯ", "pattern": [{"LOWER": "валидировать"}]},
    {"label": "ВАЛИДАЦИЯ", "pattern": [{"LOWER": "проверить"}]},
]
ruler.add_patterns(patterns)

class UserStoryParser:
    def __init__(self):
        self.nlp = spacy.load("ru_core_news_lg")

    def parse_story(self, story_text):
        """Парсинг пользовательской истории в структурированный формат"""
        doc = self.nlp(story_text)

        parsed = {
            "актёр": self._extract_actor(doc),
            "действия": self._extract_actions(doc),
            "объекты": self._extract_objects(doc),
            "ограничения": self._extract_constraints(doc),
            "предусловия": self._extract_preconditions(doc),
            "результаты": self._extract_outcomes(doc)
        }

        return parsed

    def _extract_actor(self, doc):
        """Извлечь основного актёра из паттерна 'Как...'"""
        for i, token in enumerate(doc):
            if token.text.lower() == "как" and i + 1 < len(doc):
                # Найти именную группу после "как"
                for chunk in doc.noun_chunks:
                    if chunk.start >= i and chunk.root.pos_ == "NOUN":
                        return chunk.text
        return None

    def _extract_actions(self, doc):
        """Извлечь глаголы, представляющие действия"""
        actions = []
        for token in doc:
            if token.pos_ == "VERB" and token.dep_ in ["ROOT", "xcomp"]:
                # Получить глагольную фразу
                verb_phrase = " ".join([t.text for t in token.subtree])
                actions.append({
                    "глагол": token.lemma_,
                    "фраза": verb_phrase,
                    "отрицание": self._is_negated(token)
                })
        return actions

    def _extract_constraints(self, doc):
        """Извлечь ограничения (время, количество, формат)"""
        constraints = []

        # Извлечь численные ограничения
        for ent in doc.ents:
            if ent.label_ in ["QUANTITY", "TIME", "DATE", "CARDINAL"]:
                constraints.append({
                    "тип": ent.label_,
                    "значение": ent.text,
                    "контекст": self._get_context(ent)
                })

        # Извлечь regex-подобные паттерны (напр. "мин 8 символов")
        import re
        pattern_matches = re.findall(
            r'(мин|макс|минимум|максимум|не менее|не более)\s+(\d+)\s+(\w+)',
            doc.text,
            re.IGNORECASE
        )
        for match in pattern_matches:
            constraints.append({
                "тип": "ЧИСЛЕННОЕ_ОГРАНИЧЕНИЕ",
                "оператор": match[0],
                "значение": match[1],
                "единица": match[2]
            })

        return constraints

    def _is_negated(self, token):
        """Проверить, отрицается ли глагол"""
        return any(child.dep_ == "neg" for child in token.children)

    def _get_context(self, span):
        """Получить окружающий контекст для сущности"""
        start = max(0, span.start - 3)
        end = min(len(span.doc), span.end + 3)
        return span.doc[start:end].text

# Использование
parser = UserStoryParser()
result = parser.parse_story("""
Как зарегистрированный пользователь, я хочу сбросить пароль через email,
чтобы восстановить доступ, если забуду свои учётные данные.

Критерии Приёмки:
- Пользователь вводит email-адрес на странице сброса
- Система отправляет ссылку сброса, действительную 24 часа
- Новый пароль должен содержать мин 8 символов, 1 заглавную, 1 цифру
""")

print(result)
# Вывод:
{
  "актёр": "зарегистрированный пользователь",
  "действия": [
    {"глагол": "сбросить", "фраза": "сбросить пароль", "отрицание": False},
    {"глагол": "вводить", "фраза": "вводит email-адрес", "отрицание": False},
    {"глагол": "отправлять", "фраза": "отправляет ссылку сброса", "отрицание": False}
  ],
  "ограничения": [
    {"тип": "TIME", "значение": "24 часа", "контекст": "действительную 24 часа"},
    {"тип": "ЧИСЛЕННОЕ_ОГРАНИЧЕНИЕ", "оператор": "мин", "значение": "8", "единица": "символов"}
  ],
  "объекты": ["пароль", "email", "ссылка сброса", "email-адрес"],
  "результаты": ["восстановить доступ"]
}

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
import torch

# Загрузить предобученный BERT
tokenizer = BertTokenizer.from_pretrained('DeepPavlov/rubert-base-cased')
model = BertForSequenceClassification.from_pretrained(
    'DeepPavlov/rubert-base-cased',
    num_labels=5  # Типы действий: СОЗДАТЬ, ПРОЧИТАТЬ, ОБНОВИТЬ, УДАЛИТЬ, ВАЛИДИРОВАТЬ
)

# Подготовить обучающие данные
training_examples = [
    {"текст": "Пользователь создаёт новую учётную запись", "метка": 0},  # СОЗДАТЬ
    {"текст": "Система отображает профиль пользователя", "метка": 1},  # ПРОЧИТАТЬ
    {"текст": "Пользователь обновляет пароль", "метка": 2},  # ОБНОВИТЬ
    {"текст": "Админ удаляет пользователя", "метка": 3},  # УДАЛИТЬ
    {"текст": "Система валидирует формат email", "метка": 4},  # ВАЛИДИРОВАТЬ
    # ... сотни дополнительных примеров
]

class RequirementsDataset(torch.utils.data.Dataset):
    def __init__(self, texts, labels, tokenizer):
        self.encodings = tokenizer(texts, truncation=True, padding=True)
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

# Создать датасет
texts = [ex["текст"] for ex in training_examples]
labels = [ex["метка"] for ex in training_examples]
dataset = RequirementsDataset(texts, labels, tokenizer)

# Конфигурация обучения
training_args = TrainingArguments(
    output_dir='./requirements-classifier',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset
)

# Fine-tune
trainer.train()

class IntentRecognizer:
    def __init__(self, model_path):
        self.tokenizer = BertTokenizer.from_pretrained(model_path)
        self.model = BertForSequenceClassification.from_pretrained(model_path)
        self.model.eval()

        self.intent_labels = [
            "СОЗДАТЬ", "ПРОЧИТАТЬ", "ОБНОВИТЬ", "УДАЛИТЬ", "ВАЛИДИРОВАТЬ",
            "НАВИГИРОВАТЬ", "ПОИСК", "ФИЛЬТР", "АУТЕНТИФИЦИРОВАТЬ", "АВТОРИЗОВАТЬ"
        ]

    def recognize_intent(self, sentence):
        """Классифицировать намерение предложения требования"""
        inputs = self.tokenizer(
            sentence,
            return_tensors="pt",
            truncation=True,
            padding=True
        )

        with torch.no_grad():
            outputs = self.model(**inputs)
            predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

        intent_idx = predictions.argmax().item()
        confidence = predictions[0][intent_idx].item()

        return {
            "намерение": self.intent_labels[intent_idx],
            "уверенность": confidence,
            "все_вероятности": {
                label: prob.item()
                for label, prob in zip(self.intent_labels, predictions[0])
            }
        }

# Использование
recognizer = IntentRecognizer('./requirements-classifier')

result = recognizer.recognize_intent(
    "Система валидирует формат email перед отправкой"
)

print(result)
# Вывод:
{
  "намерение": "ВАЛИДИРОВАТЬ",
  "уверенность": 0.94,
  "все_вероятности": {
    "СОЗДАТЬ": 0.01,
    "ПРОЧИТАТЬ": 0.02,
    "ОБНОВИТЬ": 0.01,
    "УДАЛИТЬ": 0.00,
    "ВАЛИДИРОВАТЬ": 0.94,
    "НАВИГИРОВАТЬ": 0.01,
    ...
  }
}

class ScenarioGenerator:
    def __init__(self):
        self.templates = {
            "СОЗДАТЬ": [
                "ПОЗИТИВНЫЙ: {актёр} успешно создаёт {объект}",
                "НЕГАТИВНЫЙ: {актёр} не может создать {объект} с невалидным {поле}",
                "ГРАНИЧНЫЙ: {актёр} создаёт {объект} с минимальными валидными данными",
                "ГРАНИЧНЫЙ: {актёр} создаёт {объект} с максимальными валидными данными",
                "БЕЗОПАСНОСТЬ: Неавторизованный пользователь пытается создать {объект}"
            ],
            "ОБНОВИТЬ": [
                "ПОЗИТИВНЫЙ: {актёр} успешно обновляет {объект}",
                "НЕГАТИВНЫЙ: {актёр} не может обновить несуществующий {объект}",
                "НЕГАТИВНЫЙ: {актёр} не может обновить {объект} с невалидными данными",
                "ПАРАЛЛЕЛИЗМ: Два пользователя обновляют один {объект} одновременно"
            ],
            "УДАЛИТЬ": [
                "ПОЗИТИВНЫЙ: {актёр} успешно удаляет {объект}",
                "НЕГАТИВНЫЙ: {актёр} не может удалить несуществующий {объект}",
                "БЕЗОПАСНОСТЬ: Неавторизованный пользователь пытается удалить {объект}",
                "КАСКАД: Удаление {объект} удаляет связанные зависимости"
            ],
            "ВАЛИДИРОВАТЬ": [
                "ПОЗИТИВНЫЙ: {объект} проходит валидацию с валидным {ограничение}",
                "НЕГАТИВНЫЙ: {объект} не проходит валидацию с невалидным {ограничение}",
                "ГРАНИЦА: валидация {объект} на мин/макс значениях {ограничение}"
            ]
        }

    def generate_scenarios(self, parsed_requirement):
        """Генерация тестовых сценариев из распарсенного требования"""
        intent = parsed_requirement["намерение"]
        actor = parsed_requirement["актёр"]
        objects = parsed_requirement["объекты"]
        constraints = parsed_requirement["ограничения"]

        scenarios = []

        # Получить шаблоны для этого намерения
        templates = self.templates.get(intent, [])

        for obj in objects:
            for template in templates:
                scenario = template.format(
                    актёр=actor,
                    объект=obj,
                    поле=self._extract_fields(constraints),
                    ограничение=self._format_constraints(constraints)
                )
                scenarios.append({
                    "описание": scenario,
                    "тип": self._extract_type(template),
                    "приоритет": self._calculate_priority(template, constraints)
                })

        return scenarios

    def _extract_type(self, template):
        """Извлечь тип сценария из шаблона"""
        if template.startswith("ПОЗИТИВНЫЙ"):
            return "позитивный"
        elif template.startswith("НЕГАТИВНЫЙ"):
            return "негативный"
        elif template.startswith("ГРАНИЧНЫЙ"):
            return "граничный"
        elif template.startswith("БЕЗОПАСНОСТЬ"):
            return "безопасность"
        else:
            return "другой"

    def _calculate_priority(self, template, constraints):
        """Рассчитать приоритет на основе шаблона и ограничений"""
        priority = 3  # Средний по умолчанию

        if template.startswith("ПОЗИТИВНЫЙ"):
            priority = 1  # Высокий
        elif template.startswith("БЕЗОПАСНОСТЬ"):
            priority = 1  # Высокий
        elif len(constraints) > 0:
            priority = 2  # Средне-высокий для сценариев с ограничениями

        return priority

    def _extract_fields(self, constraints):
        """Извлечь названия полей из ограничений"""
        fields = [c.get("единица", "поле") for c in constraints]
        return fields[0] if fields else "данные"

    def _format_constraints(self, constraints):
        """Отформатировать ограничения как читаемую строку"""
        if not constraints:
            return "данные"
        return ", ".join([f"{c.get('значение', '')} {c.get('единица', '')}"
                         for c in constraints])

# Использование
generator = ScenarioGenerator()

parsed = {
    "намерение": "СОЗДАТЬ",
    "актёр": "зарегистрированный пользователь",
    "объекты": ["пароль"],
    "ограничения": [
        {"значение": "8", "единица": "символов", "оператор": "мин"},
        {"значение": "1", "единица": "заглавная"},
        {"значение": "1", "единица": "цифра"}
    ]
}

scenarios = generator.generate_scenarios(parsed)

for scenario in scenarios:
    print(f"[{scenario['тип'].upper()}] {scenario['описание']}")

# Вывод:
# [ПОЗИТИВНЫЙ] зарегистрированный пользователь успешно создаёт пароль
# [НЕГАТИВНЫЙ] зарегистрированный пользователь не может создать пароль с невалидным символов
# [ГРАНИЧНЫЙ] зарегистрированный пользователь создаёт пароль с минимальными валидными данными
# [ГРАНИЧНЫЙ] зарегистрированный пользователь создаёт пароль с максимальными валидными данными
# [БЕЗОПАСНОСТЬ] Неавторизованный пользователь пытается создать пароль

Функционал: Сброс Пароля
  Как зарегистрированный пользователь
  Я хочу сбросить пароль через email
  Чтобы восстановить доступ, если забуду учётные данные

  Предыстория:
    Дано я зарегистрированный пользователь
    И у меня есть доступ к моему email

  Сценарий: Успешный сброс пароля
    Дано я на странице сброса пароля
    Когда я ввожу мой email-адрес "user@example.com"
    И я кликаю кнопку "Отправить Ссылку Сброса"
    Тогда я должен видеть подтверждающее сообщение
    И я должен получить email сброса пароля
    Когда я кликаю ссылку сброса в email
    И я ввожу новый пароль "NewPass123"
    И я подтверждаю новый пароль "NewPass123"
    И я кликаю кнопку "Сбросить Пароль"
    Тогда я должен видеть сообщение об успехе
    И я должен иметь возможность войти с новым паролем

  Сценарий: Истечение срока ссылки сброса
    Дано я запросил сброс пароля
    И прошло 25 часов
    Когда я кликаю ссылку сброса
    Тогда я должен видеть сообщение об ошибке "Ссылка истекла"

class GherkinGenerator:
    def __init__(self):
        self.step_templates = {
            "ДАНО": {
                "навигация": "я на {страница}",
                "авторизован": "я вошёл как {актёр}",
                "данные_существуют": "{объект} существует с {атрибуты}",
                "состояние": "система в состоянии {состояние}"
            },
            "КОГДА": {
                "клик": "я кликаю {тип_элемента} \"{элемент}\"",
                "ввод": "я ввожу \"{значение}\" в поле \"{поле}\"",
                "выбор": "я выбираю \"{опция}\" из \"{выпадающий_список}\"",
                "отправка": "я отправляю форму {имя_формы}",
                "навигация": "я перехожу на {страница}"
            },
            "ТОГДА": {
                "видеть_сообщение": "я должен видеть сообщение {тип_сообщения} \"{сообщение}\"",
                "видеть_элемент": "я должен видеть {тип_элемента} \"{элемент}\"",
                "редирект": "я должен быть перенаправлен на {страница}",
                "данные_сохранены": "{объект} должен быть сохранён с {атрибуты}",
                "ошибка_валидации": "я должен видеть ошибку валидации для \"{поле}\""
            }
        }

    def generate_feature(self, user_story, scenarios):
        """Генерировать полный Gherkin feature-файл"""

        feature = f"""Функционал: {user_story['заголовок']}
  {user_story['описание']}

"""

        # Добавить предысторию, если есть общие предусловия
        background = self._generate_background(scenarios)
        if background:
            feature += f"{background}\n\n"

        # Генерировать сценарии
        for scenario in scenarios:
            feature += self._generate_scenario(scenario) + "\n\n"

        return feature

    def _generate_scenario(self, scenario_data):
        """Генерировать один Gherkin-сценарий"""

        scenario = f"  Сценарий: {scenario_data['название']}\n"

        # Шаги Дано (предусловия)
        for given in scenario_data.get('предусловия', []):
            scenario += f"    Дано {self._format_step(given, 'ДАНО')}\n"

        # Шаги Когда (действия)
        for when in scenario_data.get('действия', []):
            scenario += f"    Когда {self._format_step(when, 'КОГДА')}\n"

        # Шаги Тогда (утверждения)
        for then in scenario_data.get('результаты', []):
            scenario += f"    Тогда {self._format_step(then, 'ТОГДА')}\n"

        return scenario

    def _format_step(self, step_data, step_type):
        """Отформатировать шаг, используя шаблоны"""
        template_key = step_data.get('шаблон', 'default')
        template = self.step_templates[step_type].get(template_key, "{текст}")

        return template.format(**step_data.get('параметры', {}))

    def _generate_background(self, scenarios):
        """Извлечь общие предусловия как Предысторию"""
        # Найти шаги, общие для всех сценариев
        common_steps = self._find_common_steps(scenarios)

        if not common_steps:
            return None

        background = "  Предыстория:\n"
        for step in common_steps:
            background += f"    Дано {step}\n"

        return background

    def _find_common_steps(self, scenarios):
        """Найти шаги, присутствующие во всех сценариях"""
        if not scenarios:
            return []

        first_preconditions = set(
            self._step_to_string(s)
            for s in scenarios[0].get('предусловия', [])
        )

        for scenario in scenarios[1:]:
            scenario_preconditions = set(
                self._step_to_string(s)
                for s in scenario.get('предусловия', [])
            )
            first_preconditions &= scenario_preconditions

        return list(first_preconditions)

    def _step_to_string(self, step):
        """Преобразовать данные шага в строку для сравнения"""
        return f"{step.get('шаблон', '')}:{step.get('параметры', {})}"

# Использование
generator = GherkinGenerator()

user_story_info = {
    "заголовок": "Сброс Пароля",
    "описание": "Как зарегистрированный пользователь, я хочу сбросить пароль..."
}

gherkin_scenarios = [
    {
        "название": "Успешный сброс пароля",
        "предусловия": [
            {"шаблон": "навигация", "параметры": {"страница": "страница сброса"}}
        ],
        "действия": [
            {"шаблон": "ввод", "параметры": {"значение": "user@example.com", "поле": "email"}}
        ],
        "результаты": [
            {"шаблон": "видеть_сообщение", "параметры": {"тип_сообщения": "успех", "сообщение": "Пароль сброшен"}}
        ]
    }
]

feature_file = generator.generate_feature(
    user_story_info,
    gherkin_scenarios
)

print(feature_file)

from jira import JIRA
import requests

class JiraTestIntegration:
    def __init__(self, jira_url, api_token):
        self.jira = JIRA(server=jira_url, token_auth=api_token)
        self.nlp_pipeline = NLPToGherkinPipeline()

    def process_user_story(self, issue_key):
        """Обработать пользовательскую историю Jira и создать тест-кейсы"""

        # Получить пользовательскую историю из Jira
        issue = self.jira.issue(issue_key)

        user_story = {
            "заголовок": issue.fields.summary,
            "описание": issue.fields.description,
            "критерии_приёмки": self._extract_acceptance_criteria(issue)
        }

        # Генерировать тестовые сценарии с помощью NLP
        full_text = f"{user_story['описание']}\n\n{user_story['критерии_приёмки']}"
        scenarios = self.nlp_pipeline.convert_to_gherkin(full_text)

        # Создать тест-кейсы в Jira (используя X-Ray или Zephyr)
        test_cases = self._create_test_cases(issue_key, scenarios)

        # Связать тесты с пользовательской историей
        self._link_tests_to_story(issue_key, test_cases)

        return test_cases

    def _extract_acceptance_criteria(self, issue):
        """Извлечь критерии приёмки из Jira issue"""
        # Проверить кастомное поле или парсить из описания
        ac_field = getattr(issue.fields, 'customfield_10100', None)
        if ac_field:
            return ac_field

        # Парсить из описания, если используется маркер "КП:"
        description = issue.fields.description or ""
        if "Критерии Приёмки:" in description:
            parts = description.split("Критерии Приёмки:")
            return parts[1] if len(parts) > 1 else ""

        return ""

    def _create_test_cases(self, story_key, gherkin_scenarios):
        """Создать тест-кейсы в Jira X-Ray"""
        test_cases = []

        # Парсить Gherkin для извлечения сценариев
        scenarios = self._parse_gherkin(gherkin_scenarios)

        for scenario in scenarios:
            # Создать тестовый issue
            test_issue = self.jira.create_issue(
                project='TEST',
                summary=f"Тест: {scenario['название']}",
                description=self._format_test_description(scenario),
                issuetype={'name': 'Test'},
                customfield_10200=scenario['gherkin']  # Поле Gherkin в X-Ray
            )

            test_cases.append(test_issue.key)

        return test_cases

    def _link_tests_to_story(self, story_key, test_keys):
        """Создать связи 'Tests' от пользовательской истории к тест-кейсам"""
        for test_key in test_keys:
            self.jira.create_issue_link(
                type="Tests",
                inwardIssue=test_key,
                outwardIssue=story_key
            )

    def _parse_gherkin(self, gherkin_text):
        """Парсить текст Gherkin в сценарии"""
        scenarios = []
        current_scenario = None

        for line in gherkin_text.split('\n'):
            line = line.strip()

            if line.startswith('Сценарий:'):
                if current_scenario:
                    scenarios.append(current_scenario)
                current_scenario = {
                    "название": line.replace('Сценарий:', '').strip(),
                    "шаги": [],
                    "gherkin": ""
                }
            elif current_scenario and line:
                current_scenario['шаги'].append(line)
                current_scenario['gherkin'] += line + '\n'

        if current_scenario:
            scenarios.append(current_scenario)

        return scenarios

    def _format_test_description(self, scenario):
        """Отформатировать сценарий как описание теста"""
        description = f"**Тестовый Сценарий**: {scenario['название']}\n\n"
        description += "**Шаги**:\n"
        for step in scenario['шаги']:
            description += f"- {step}\n"
        return description

# Использование
integration = JiraTestIntegration(
    jira_url='https://yourcompany.atlassian.net',
    api_token='your_api_token'
)

# Обработать пользовательскую историю и авто-генерировать тесты
test_cases = integration.process_user_story('PROJ-123')
print(f"Создано {len(test_cases)} тест-кейсов: {test_cases}")

# Вывод:
# Создано 5 тест-кейсов: ['TEST-456', 'TEST-457', 'TEST-458', 'TEST-459', 'TEST-460']

# Использовать GPT-4 для генерации сценариев без обучения
import openai

def generate_scenarios_gpt4(user_story):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "system",
            "content": "Ты QA-эксперт. Генерируй полные тестовые сценарии из пользовательских историй в формате Gherkin."
        }, {
            "role": "user",
            "content": f"Сгенерируй тестовые сценарии для:\n{user_story}"
        }],
        temperature=0.3
    )
    return response.choices[0].message.content