NLP para Convertir Requisitos en Tests: De User Stories a BDD Automatizado

# Usando spaCy para extracción de entidades
import spacy

nlp = spacy.load("es_core_news_lg")
doc = nlp(texto_historia_usuario)

# Extraer entidades
entidades = {
    "ACTOR": [],        # usuario registrado
    "ACCIÓN": [],       # restablecer, enviar, hacer clic, establecer
    "OBJETO": [],       # contraseña, email, enlace
    "RESTRICCIÓN": [],  # 24 horas, mín 8 caracteres, 1 mayúscula, 1 número
    "SISTEMA": []       # página de reseteo, sistema de email
}

for ent in doc.ents:
    if ent.label_ == "PER":
        entidades["ACTOR"].append(ent.text)
    elif ent.label_ in ["TIME", "DATE", "QUANTITY"]:
        entidades["RESTRICCIÓN"].append(ent.text)

# Salida:
{
  "ACTOR": ["usuario registrado"],
  "ACCIÓN": ["restablecer", "enviar", "hacer clic", "establecer"],
  "OBJETO": ["contraseña", "dirección de email", "enlace de reseteo", "nueva contraseña"],
  "RESTRICCIÓN": ["24 horas", "mín 8 caracteres", "1 mayúscula", "1 número"],
  "SISTEMA": ["página de reseteo", "Sistema"]
}

# Instalar spaCy con modelo transformer
pip install spacy transformers
python -m spacy download es_core_news_trf

# Cargar modelo
import spacy
nlp = spacy.load("es_core_news_trf")

# Agregar reconocedor personalizado de entidades para términos específicos del dominio
from spacy.pipeline import EntityRuler

ruler = nlp.add_pipe("entity_ruler", before="ner")
patterns = [
    {"label": "ELEMENTO_UI", "pattern": [{"LOWER": "botón"}]},
    {"label": "ELEMENTO_UI", "pattern": [{"LOWER": "formulario"}]},
    {"label": "ELEMENTO_UI", "pattern": [{"LOWER": "página"}]},
    {"label": "ACCIÓN", "pattern": [{"LOWER": "clic"}]},
    {"label": "ACCIÓN", "pattern": [{"LOWER": "ingresar"}]},
    {"label": "ACCIÓN", "pattern": [{"LOWER": "enviar"}]},
    {"label": "VALIDACIÓN", "pattern": [{"LOWER": "validar"}]},
    {"label": "VALIDACIÓN", "pattern": [{"LOWER": "verificar"}]},
]
ruler.add_patterns(patterns)

class ParserHistoriaUsuario:
    def __init__(self):
        self.nlp = spacy.load("es_core_news_trf")

    def parsear_historia(self, texto_historia):
        """Parsear historia de usuario en formato estructurado"""
        doc = self.nlp(texto_historia)

        parseado = {
            "actor": self._extraer_actor(doc),
            "acciones": self._extraer_acciones(doc),
            "objetos": self._extraer_objetos(doc),
            "restricciones": self._extraer_restricciones(doc),
            "precondiciones": self._extraer_precondiciones(doc),
            "resultados": self._extraer_resultados(doc)
        }

        return parseado

    def _extraer_actor(self, doc):
        """Extraer actor principal del patrón 'Como...'"""
        for i, token in enumerate(doc):
            if token.text.lower() == "como" and i + 1 < len(doc):
                # Encontrar frase nominal después de "como"
                for chunk in doc.noun_chunks:
                    if chunk.start >= i and chunk.root.pos_ == "NOUN":
                        return chunk.text
        return None

    def _extraer_acciones(self, doc):
        """Extraer verbos que representan acciones"""
        acciones = []
        for token in doc:
            if token.pos_ == "VERB" and token.dep_ in ["ROOT", "xcomp"]:
                # Obtener frase verbal
                frase_verbal = " ".join([t.text for t in token.subtree])
                acciones.append({
                    "verbo": token.lemma_,
                    "frase": frase_verbal,
                    "negado": self._esta_negado(token)
                })
        return acciones

    def _extraer_restricciones(self, doc):
        """Extraer restricciones (tiempo, cantidad, formato)"""
        restricciones = []

        # Extraer restricciones numéricas
        for ent in doc.ents:
            if ent.label_ in ["QUANTITY", "TIME", "DATE", "CARDINAL"]:
                restricciones.append({
                    "tipo": ent.label_,
                    "valor": ent.text,
                    "contexto": self._obtener_contexto(ent)
                })

        # Extraer patrones tipo regex (ej. "mín 8 caracteres")
        import re
        coincidencias_patron = re.findall(
            r'(mín|máx|al menos|como máximo)\s+(\d+)\s+(\w+)',
            doc.text,
            re.IGNORECASE
        )
        for coincidencia in coincidencias_patron:
            restricciones.append({
                "tipo": "RESTRICCIÓN_NUMÉRICA",
                "operador": coincidencia[0],
                "valor": coincidencia[1],
                "unidad": coincidencia[2]
            })

        return restricciones

    def _esta_negado(self, token):
        """Verificar si verbo está negado"""
        return any(child.dep_ == "neg" for child in token.children)

    def _obtener_contexto(self, span):
        """Obtener contexto circundante para una entidad"""
        inicio = max(0, span.start - 3)
        fin = min(len(span.doc), span.end + 3)
        return span.doc[inicio:fin].text

# Uso
parser = ParserHistoriaUsuario()
resultado = parser.parsear_historia("""
Como usuario registrado, quiero restablecer mi contraseña por email
para poder recuperar acceso si olvido mis credenciales.

Criterios de Aceptación:
- Usuario ingresa dirección de email en página de reseteo
- Sistema envía enlace de reseteo válido por 24 horas
- Nueva contraseña debe contener mín 8 caracteres, 1 mayúscula, 1 número
""")

print(resultado)
# Salida:
{
  "actor": "usuario registrado",
  "acciones": [
    {"verbo": "restablecer", "frase": "restablecer mi contraseña", "negado": False},
    {"verbo": "ingresar", "frase": "ingresa dirección de email", "negado": False},
    {"verbo": "enviar", "frase": "envía enlace de reseteo", "negado": False}
  ],
  "restricciones": [
    {"tipo": "TIME", "valor": "24 horas", "contexto": "válido por 24 horas"},
    {"tipo": "RESTRICCIÓN_NUMÉRICA", "operador": "mín", "valor": "8", "unidad": "caracteres"}
  ],
  "objetos": ["contraseña", "email", "enlace de reseteo", "dirección de email"],
  "resultados": ["recuperar acceso"]
}

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

# Cargar BERT pre-entrenado
tokenizer = BertTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')
model = BertForSequenceClassification.from_pretrained(
    'dccuchile/bert-base-spanish-wwm-uncased',
    num_labels=5  # Tipos de acción: CREAR, LEER, ACTUALIZAR, ELIMINAR, VALIDAR
)

# Preparar datos de entrenamiento
ejemplos_entrenamiento = [
    {"texto": "Usuario crea nueva cuenta", "etiqueta": 0},  # CREAR
    {"texto": "Sistema muestra perfil de usuario", "etiqueta": 1},  # LEER
    {"texto": "Usuario actualiza contraseña", "etiqueta": 2},  # ACTUALIZAR
    {"texto": "Admin elimina usuario", "etiqueta": 3},  # ELIMINAR
    {"texto": "Sistema valida formato de email", "etiqueta": 4},  # VALIDAR
    # ... cientos más de ejemplos
]

class DatasetRequisitos(torch.utils.data.Dataset):
    def __init__(self, textos, etiquetas, tokenizer):
        self.encodings = tokenizer(textos, truncation=True, padding=True)
        self.etiquetas = etiquetas

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

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

# Crear dataset
textos = [ej["texto"] for ej in ejemplos_entrenamiento]
etiquetas = [ej["etiqueta"] for ej in ejemplos_entrenamiento]
dataset = DatasetRequisitos(textos, etiquetas, tokenizer)

# Configuración de entrenamiento
args_entrenamiento = TrainingArguments(
    output_dir='./clasificador-requisitos',
    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=args_entrenamiento,
    train_dataset=dataset
)

# Fine-tune
trainer.train()

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

        self.etiquetas_intencion = [
            "CREAR", "LEER", "ACTUALIZAR", "ELIMINAR", "VALIDAR",
            "NAVEGAR", "BUSCAR", "FILTRAR", "AUTENTICAR", "AUTORIZAR"
        ]

    def reconocer_intencion(self, oracion):
        """Clasificar intención de oración de requisito"""
        inputs = self.tokenizer(
            oracion,
            return_tensors="pt",
            truncation=True,
            padding=True
        )

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

        idx_intencion = predictions.argmax().item()
        confianza = predictions[0][idx_intencion].item()

        return {
            "intencion": self.etiquetas_intencion[idx_intencion],
            "confianza": confianza,
            "todas_probabilidades": {
                etiqueta: prob.item()
                for etiqueta, prob in zip(self.etiquetas_intencion, predictions[0])
            }
        }

# Uso
reconocedor = ReconocedorIntencion('./clasificador-requisitos')

resultado = reconocedor.reconocer_intencion(
    "Sistema valida formato de email antes de envío"
)

print(resultado)
# Salida:
{
  "intencion": "VALIDAR",
  "confianza": 0.94,
  "todas_probabilidades": {
    "CREAR": 0.01,
    "LEER": 0.02,
    "ACTUALIZAR": 0.01,
    "ELIMINAR": 0.00,
    "VALIDAR": 0.94,
    "NAVEGAR": 0.01,
    ...
  }
}

class GeneradorEscenarios:
    def __init__(self):
        self.plantillas = {
            "CREAR": [
                "POSITIVO: {actor} crea exitosamente {objeto}",
                "NEGATIVO: {actor} falla al crear {objeto} con {campo} inválido",
                "EDGE: {actor} crea {objeto} con datos mínimos válidos",
                "EDGE: {actor} crea {objeto} con datos máximos válidos",
                "SEGURIDAD: Usuario no autorizado intenta crear {objeto}"
            ],
            "ACTUALIZAR": [
                "POSITIVO: {actor} actualiza exitosamente {objeto}",
                "NEGATIVO: {actor} falla al actualizar {objeto} inexistente",
                "NEGATIVO: {actor} falla al actualizar {objeto} con datos inválidos",
                "CONCURRENCIA: Dos usuarios actualizan mismo {objeto} simultáneamente"
            ],
            "ELIMINAR": [
                "POSITIVO: {actor} elimina exitosamente {objeto}",
                "NEGATIVO: {actor} falla al eliminar {objeto} inexistente",
                "SEGURIDAD: Usuario no autorizado intenta eliminar {objeto}",
                "CASCADE: Eliminar {objeto} remueve dependencias relacionadas"
            ],
            "VALIDAR": [
                "POSITIVO: {objeto} pasa validación con {restriccion} válida",
                "NEGATIVO: {objeto} falla validación con {restriccion} inválida",
                "LÍMITE: validación de {objeto} en valores mín/máx de {restriccion}"
            ]
        }

    def generar_escenarios(self, requisito_parseado):
        """Generar escenarios de prueba desde requisito parseado"""
        intencion = requisito_parseado["intencion"]
        actor = requisito_parseado["actor"]
        objetos = requisito_parseado["objetos"]
        restricciones = requisito_parseado["restricciones"]

        escenarios = []

        # Obtener plantillas para esta intención
        plantillas = self.plantillas.get(intencion, [])

        for obj in objetos:
            for plantilla in plantillas:
                escenario = plantilla.format(
                    actor=actor,
                    objeto=obj,
                    campo=self._extraer_campos(restricciones),
                    restriccion=self._formatear_restricciones(restricciones)
                )
                escenarios.append({
                    "descripcion": escenario,
                    "tipo": self._extraer_tipo(plantilla),
                    "prioridad": self._calcular_prioridad(plantilla, restricciones)
                })

        return escenarios

    def _extraer_tipo(self, plantilla):
        """Extraer tipo de escenario desde plantilla"""
        if plantilla.startswith("POSITIVO"):
            return "positivo"
        elif plantilla.startswith("NEGATIVO"):
            return "negativo"
        elif plantilla.startswith("EDGE"):
            return "edge"
        elif plantilla.startswith("SEGURIDAD"):
            return "seguridad"
        else:
            return "otro"

    def _calcular_prioridad(self, plantilla, restricciones):
        """Calcular prioridad basada en plantilla y restricciones"""
        prioridad = 3  # Media por defecto

        if plantilla.startswith("POSITIVO"):
            prioridad = 1  # Alta
        elif plantilla.startswith("SEGURIDAD"):
            prioridad = 1  # Alta
        elif len(restricciones) > 0:
            prioridad = 2  # Media-alta para escenarios restringidos

        return prioridad

    def _extraer_campos(self, restricciones):
        """Extraer nombres de campos desde restricciones"""
        campos = [r.get("unidad", "campo") for r in restricciones]
        return campos[0] if campos else "datos"

    def _formatear_restricciones(self, restricciones):
        """Formatear restricciones como string legible"""
        if not restricciones:
            return "datos"
        return ", ".join([f"{r.get('valor', '')} {r.get('unidad', '')}"
                         for r in restricciones])

# Uso
generador = GeneradorEscenarios()

parseado = {
    "intencion": "CREAR",
    "actor": "usuario registrado",
    "objetos": ["contraseña"],
    "restricciones": [
        {"valor": "8", "unidad": "caracteres", "operador": "mín"},
        {"valor": "1", "unidad": "mayúscula"},
        {"valor": "1", "unidad": "número"}
    ]
}

escenarios = generador.generar_escenarios(parseado)

for escenario in escenarios:
    print(f"[{escenario['tipo'].upper()}] {escenario['descripcion']}")

# Salida:
# [POSITIVO] usuario registrado crea exitosamente contraseña
# [NEGATIVO] usuario registrado falla al crear contraseña con caracteres inválido
# [EDGE] usuario registrado crea contraseña con datos mínimos válidos
# [EDGE] usuario registrado crea contraseña con datos máximos válidos
# [SEGURIDAD] Usuario no autorizado intenta crear contraseña

Característica: Restablecimiento de Contraseña
  Como usuario registrado
  Quiero restablecer mi contraseña por email
  Para poder recuperar acceso si olvido mis credenciales

  Antecedentes:
    Dado que soy un usuario registrado
    Y tengo acceso a mi email

  Escenario: Restablecimiento exitoso de contraseña
    Dado que estoy en la página de restablecimiento de contraseña
    Cuando ingreso mi dirección de email "usuario@ejemplo.com"
    Y hago clic en el botón "Enviar Enlace de Reseteo"
    Entonces debería ver un mensaje de confirmación
    Y debería recibir un email de restablecimiento de contraseña
    Cuando hago clic en el enlace de reseteo en el email
    Y ingreso una nueva contraseña "NuevaContraseña123"
    Y confirmo la nueva contraseña "NuevaContraseña123"
    Y hago clic en el botón "Restablecer Contraseña"
    Entonces debería ver un mensaje de éxito
    Y debería poder iniciar sesión con la nueva contraseña

  Escenario: Expiración de enlace de reseteo
    Dado que he solicitado un restablecimiento de contraseña
    Y han pasado 25 horas
    Cuando hago clic en el enlace de reseteo
    Entonces debería ver un mensaje de error "Enlace expirado"

class GeneradorGherkin:
    def __init__(self):
        self.plantillas_pasos = {
            "DADO": {
                "navegar": "estoy en la {pagina}",
                "autenticado": "he iniciado sesión como {actor}",
                "datos_existen": "{objeto} existe con {atributos}",
                "estado": "el sistema está en estado {estado}"
            },
            "CUANDO": {
                "clic": "hago clic en el {tipo_elemento} \"{elemento}\"",
                "ingresar": "ingreso \"{valor}\" en el campo \"{campo}\"",
                "seleccionar": "selecciono \"{opcion}\" de \"{dropdown}\"",
                "enviar": "envío el formulario {nombre_formulario}",
                "navegar": "navego a {pagina}"
            },
            "ENTONCES": {
                "ver_mensaje": "debería ver un mensaje de {tipo_mensaje} \"{mensaje}\"",
                "ver_elemento": "debería ver el {tipo_elemento} \"{elemento}\"",
                "redirigir": "debería ser redirigido a {pagina}",
                "datos_guardados": "{objeto} debería guardarse con {atributos}",
                "error_validacion": "debería ver un error de validación para \"{campo}\""
            }
        }

    def generar_caracteristica(self, historia_usuario, escenarios):
        """Generar archivo Gherkin completo"""

        caracteristica = f"""Característica: {historia_usuario['titulo']}
  {historia_usuario['descripcion']}

"""

        # Agregar antecedentes si existen precondiciones comunes
        antecedentes = self._generar_antecedentes(escenarios)
        if antecedentes:
            caracteristica += f"{antecedentes}\n\n"

        # Generar escenarios
        for escenario in escenarios:
            caracteristica += self._generar_escenario(escenario) + "\n\n"

        return caracteristica

    def _generar_escenario(self, datos_escenario):
        """Generar escenario Gherkin individual"""

        escenario = f"  Escenario: {datos_escenario['nombre']}\n"

        # Pasos Dado (precondiciones)
        for dado in datos_escenario.get('precondiciones', []):
            escenario += f"    Dado que {self._formatear_paso(dado, 'DADO')}\n"

        # Pasos Cuando (acciones)
        for cuando in datos_escenario.get('acciones', []):
            escenario += f"    Cuando {self._formatear_paso(cuando, 'CUANDO')}\n"

        # Pasos Entonces (aserciones)
        for entonces in datos_escenario.get('resultados', []):
            escenario += f"    Entonces {self._formatear_paso(entonces, 'ENTONCES')}\n"

        return escenario

    def _formatear_paso(self, datos_paso, tipo_paso):
        """Formatear paso usando plantillas"""
        clave_plantilla = datos_paso.get('plantilla', 'default')
        plantilla = self.plantillas_pasos[tipo_paso].get(clave_plantilla, "{texto}")

        return plantilla.format(**datos_paso.get('params', {}))

    def _generar_antecedentes(self, escenarios):
        """Extraer precondiciones comunes como Antecedentes"""
        # Encontrar pasos comunes a todos los escenarios
        pasos_comunes = self._encontrar_pasos_comunes(escenarios)

        if not pasos_comunes:
            return None

        antecedentes = "  Antecedentes:\n"
        for paso in pasos_comunes:
            antecedentes += f"    Dado que {paso}\n"

        return antecedentes

    def _encontrar_pasos_comunes(self, escenarios):
        """Encontrar pasos presentes en todos los escenarios"""
        if not escenarios:
            return []

        primeras_precondiciones = set(
            self._paso_a_string(p)
            for p in escenarios[0].get('precondiciones', [])
        )

        for escenario in escenarios[1:]:
            precondiciones_escenario = set(
                self._paso_a_string(p)
                for p in escenario.get('precondiciones', [])
            )
            primeras_precondiciones &= precondiciones_escenario

        return list(primeras_precondiciones)

    def _paso_a_string(self, paso):
        """Convertir datos de paso a string para comparación"""
        return f"{paso.get('plantilla', '')}:{paso.get('params', {})}"

# Uso
generador = GeneradorGherkin()

info_historia_usuario = {
    "titulo": "Restablecimiento de Contraseña",
    "descripcion": "Como usuario registrado, quiero restablecer mi contraseña..."
}

escenarios_gherkin = [
    {
        "nombre": "Restablecimiento exitoso de contraseña",
        "precondiciones": [
            {"plantilla": "navegar", "params": {"pagina": "página de restablecimiento"}}
        ],
        "acciones": [
            {"plantilla": "ingresar", "params": {"valor": "user@ejemplo.com", "campo": "email"}}
        ],
        "resultados": [
            {"plantilla": "ver_mensaje", "params": {"tipo_mensaje": "éxito", "mensaje": "Contraseña restablecida"}}
        ]
    }
]

archivo_caracteristica = generador.generar_caracteristica(
    info_historia_usuario,
    escenarios_gherkin
)

print(archivo_caracteristica)

from jira import JIRA
import requests

class IntegracionPruebasJira:
    def __init__(self, url_jira, token_api):
        self.jira = JIRA(server=url_jira, token_auth=token_api)
        self.pipeline_nlp = PipelineNLPAGherkin()

    def procesar_historia_usuario(self, clave_issue):
        """Procesar historia de usuario Jira y crear casos de prueba"""

        # Obtener historia de usuario de Jira
        issue = self.jira.issue(clave_issue)

        historia_usuario = {
            "titulo": issue.fields.summary,
            "descripcion": issue.fields.description,
            "criterios_aceptacion": self._extraer_criterios_aceptacion(issue)
        }

        # Generar escenarios de prueba usando NLP
        texto_completo = f"{historia_usuario['descripcion']}\n\n{historia_usuario['criterios_aceptacion']}"
        escenarios = self.pipeline_nlp.convertir_a_gherkin(texto_completo)

        # Crear casos de prueba en Jira (usando X-Ray o Zephyr)
        casos_prueba = self._crear_casos_prueba(clave_issue, escenarios)

        # Vincular pruebas a historia de usuario
        self._vincular_pruebas_a_historia(clave_issue, casos_prueba)

        return casos_prueba

    def _extraer_criterios_aceptacion(self, issue):
        """Extraer criterios de aceptación del issue Jira"""
        # Verificar campo personalizado o parsear desde descripción
        campo_ac = getattr(issue.fields, 'customfield_10100', None)
        if campo_ac:
            return campo_ac

        # Parsear desde descripción si usa marcador "CA:"
        descripcion = issue.fields.description or ""
        if "Criterios de Aceptación:" in descripcion:
            partes = descripcion.split("Criterios de Aceptación:")
            return partes[1] if len(partes) > 1 else ""

        return ""

    def _crear_casos_prueba(self, clave_historia, escenarios_gherkin):
        """Crear casos de prueba en Jira X-Ray"""
        casos_prueba = []

        # Parsear Gherkin para extraer escenarios
        escenarios = self._parsear_gherkin(escenarios_gherkin)

        for escenario in escenarios:
            # Crear issue de prueba
            issue_prueba = self.jira.create_issue(
                project='TEST',
                summary=f"Prueba: {escenario['nombre']}",
                description=self._formatear_descripcion_prueba(escenario),
                issuetype={'name': 'Test'},
                customfield_10200=escenario['gherkin']  # Campo Gherkin en X-Ray
            )

            casos_prueba.append(issue_prueba.key)

        return casos_prueba

    def _vincular_pruebas_a_historia(self, clave_historia, claves_prueba):
        """Crear enlaces 'Tests' desde historia de usuario a casos de prueba"""
        for clave_prueba in claves_prueba:
            self.jira.create_issue_link(
                type="Tests",
                inwardIssue=clave_prueba,
                outwardIssue=clave_historia
            )

    def _parsear_gherkin(self, texto_gherkin):
        """Parsear texto Gherkin en escenarios"""
        escenarios = []
        escenario_actual = None

        for linea in texto_gherkin.split('\n'):
            linea = linea.strip()

            if linea.startswith('Escenario:'):
                if escenario_actual:
                    escenarios.append(escenario_actual)
                escenario_actual = {
                    "nombre": linea.replace('Escenario:', '').strip(),
                    "pasos": [],
                    "gherkin": ""
                }
            elif escenario_actual and linea:
                escenario_actual['pasos'].append(linea)
                escenario_actual['gherkin'] += linea + '\n'

        if escenario_actual:
            escenarios.append(escenario_actual)

        return escenarios

    def _formatear_descripcion_prueba(self, escenario):
        """Formatear escenario como descripción de prueba"""
        descripcion = f"**Escenario de Prueba**: {escenario['nombre']}\n\n"
        descripcion += "**Pasos**:\n"
        for paso in escenario['pasos']:
            descripcion += f"- {paso}\n"
        return descripcion

# Uso
integracion = IntegracionPruebasJira(
    url_jira='https://tuempresa.atlassian.net',
    token_api='tu_token_api'
)

# Procesar historia de usuario y auto-generar pruebas
casos_prueba = integracion.procesar_historia_usuario('PROJ-123')
print(f"Creados {len(casos_prueba)} casos de prueba: {casos_prueba}")

# Salida:
# Creados 5 casos de prueba: ['TEST-456', 'TEST-457', 'TEST-458', 'TEST-459', 'TEST-460']

# Usar GPT-4 para generación de escenarios sin entrenamiento
import openai

def generar_escenarios_gpt4(historia_usuario):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "system",
            "content": "Eres un experto QA. Genera escenarios de prueba completos desde historias de usuario en formato Gherkin."
        }, {
            "role": "user",
            "content": f"Genera escenarios de prueba para:\n{historia_usuario}"
        }],
        temperature=0.3
    )
    return response.choices[0].message.content