Guía de Testing de Chatbots: Validando Sistemas de IA Conversacional

class SuiteTestIntenciones:
    def __init__(self, motor_nlu):
        self.nlu = motor_nlu
        self.casos_prueba = []

    def agregar_test_intencion(self, expresion, intencion_esperada, confianza_min=0.8):
        self.casos_prueba.append({
            'entrada': expresion,
            'intencion_esperada': intencion_esperada,
            'confianza_min': confianza_min
        })

    def ejecutar_tests(self):
        resultados = []
        for test in self.casos_prueba:
            prediccion = self.nlu.predecir_intencion(test['entrada'])

            resultados.append({
                'expresion': test['entrada'],
                'esperado': test['intencion_esperada'],
                'predicho': prediccion['intencion'],
                'confianza': prediccion['confianza'],
                'aprobado': (
                    prediccion['intencion'] == test['intencion_esperada'] and
                    prediccion['confianza'] >= test['confianza_min']
                )
            })

        return resultados

# Uso ejemplo
tests_nlu = SuiteTestIntenciones(mi_chatbot.nlu)

# Ejemplos positivos
tests_nlu.agregar_test_intencion("Quiero reservar un vuelo", "reservar_vuelo")
tests_nlu.agregar_test_intencion("Ayúdame a reservar un billete de avión", "reservar_vuelo")

# Variaciones y casos extremos
tests_nlu.agregar_test_intencion("reserbar buelo porfavor", "reservar_vuelo")  # Errores ortográficos
tests_nlu.agregar_test_intencion("RESERVAR VUELO AHORA!", "reservar_vuelo")  # Mayúsculas

resultados = tests_nlu.ejecutar_tests()
precision = sum(r['aprobado'] for r in resultados) / len(resultados)
print(f"Precisión de intenciones: {precision:.2%}")

class TestFlujoDialogo:
    def __init__(self, chatbot):
        self.chatbot = chatbot
        self.id_conversacion = None

    def iniciar_conversacion(self):
        self.id_conversacion = self.chatbot.crear_sesion()
        return self

    def enviar(self, mensaje, patrones_esperados=None):
        respuesta = self.chatbot.enviar_mensaje(
            self.id_conversacion,
            mensaje
        )

        if patrones_esperados:
            for patron in patrones_esperados:
                assert re.search(patron, respuesta['texto'], re.IGNORECASE), \
                    f"Respuesta '{respuesta['texto']}' no coincide con '{patron}'"

        return respuesta

    def verificar_contexto(self, clave, valor_esperado):
        contexto = self.chatbot.obtener_contexto(self.id_conversacion)
        actual = contexto.get(clave)

        assert actual == valor_esperado, \
            f"Desajuste de contexto: {clave}={actual}, esperado {valor_esperado}"

# Ejemplo: Flujo de reserva multi-turno
dialogo = TestFlujoDialogo(mi_chatbot).iniciar_conversacion()

dialogo.enviar(
    "Quiero reservar un hotel",
    patrones_esperados=["dónde.*ir", "destino"]
)

dialogo.enviar(
    "Barcelona",
    patrones_esperados=["cuándo.*check.*in", "fechas"]
)
dialogo.verificar_contexto('destino', 'Barcelona')

from sentence_transformers import SentenceTransformer, util

class EvaluadorRelevanciaRespuesta:
    def __init__(self):
        self.modelo = SentenceTransformer('all-MiniLM-L6-v2')

    def calcular_relevancia(self, entrada_usuario, respuesta_bot, umbral=0.5):
        embeddings = self.modelo.encode([entrada_usuario, respuesta_bot])
        similitud = util.cos_sim(embeddings[0], embeddings[1]).item()

        return {
            'puntaje_similitud': similitud,
            'es_relevante': similitud >= umbral,
            'entrada_usuario': entrada_usuario,
            'respuesta_bot': respuesta_bot
        }

from transformers import pipeline

class ValidadorSeguridad:
    def __init__(self):
        self.detector_toxicidad = pipeline(
            "text-classification",
            model="unitary/toxic-bert"
        )

    def validar_respuesta(self, respuesta_bot):
        resultado_toxicidad = self.detector_toxicidad(respuesta_bot)[0]

        return {
            'texto': respuesta_bot,
            'es_seguro': resultado_toxicidad['label'] == 'non-toxic',
            'puntaje_toxicidad': resultado_toxicidad['score']
        }

import time

class TestRendimiento:
    def __init__(self, chatbot):
        self.chatbot = chatbot

    def medir_tiempo_respuesta(self, mensaje, num_ejecuciones=100):
        tiempos_respuesta = []

        for _ in range(num_ejecuciones):
            inicio = time.time()
            self.chatbot.enviar_mensaje(mensaje)
            fin = time.time()
            tiempos_respuesta.append((fin - inicio) * 1000)

        return {
            'promedio_ms': sum(tiempos_respuesta) / len(tiempos_respuesta),
            'min_ms': min(tiempos_respuesta),
            'max_ms': max(tiempos_respuesta),
            'p95_ms': sorted(tiempos_respuesta)[int(len(tiempos_respuesta) * 0.95)]
        }

perf = TestRendimiento(mi_chatbot)
baseline = perf.medir_tiempo_respuesta("Hola")
print(f"Tiempo promedio de respuesta: {baseline['promedio_ms']:.2f}ms")

class TestAmbiguedad:
    def __init__(self, chatbot):
        self.chatbot = chatbot

    def probar_entradas_ambiguas(self):
        casos_prueba = [
            {
                'entrada': "banco",  # ¿Institución financiera o asiento?
                'esperar_clarificacion': True
            },
            {
                'entrada': "Quiero volar",  # ¿Reservar vuelo o aprender a volar?
                'esperar_clarificacion': True
            }
        ]

        for test in casos_prueba:
            respuesta = self.chatbot.enviar_mensaje(test['entrada'])

            patrones_clarificacion = [
                r"cuál de ellos",
                r"te refieres a",
                r"podrías aclarar",
                r"más específico"
            ]

            pidio_clarificacion = any(
                re.search(patron, respuesta['texto'], re.IGNORECASE)
                for patron in patrones_clarificacion
            )

            if test['esperar_clarificacion']:
                assert pidio_clarificacion, \
                    f"Bot debería haber pedido clarificación para '{test['entrada']}'"

class TestRespaldo:
    def __init__(self, chatbot):
        self.chatbot = chatbot

    def probar_fuera_de_alcance(self):
        fuera_de_alcance = [
            "¿Cuál es el sentido de la vida?",
            "asdfghjkl",
            "🚀🎉🔥",  # Solo emojis
        ]

        for texto_entrada in fuera_de_alcance:
            respuesta = self.chatbot.enviar_mensaje(texto_entrada)

            respaldos_aceptables = [
                r"no entiendo",
                r"no puedo ayudar con eso",
                r"fuera de mi experiencia"
            ]

            tiene_respaldo_aceptable = any(
                re.search(patron, respuesta['texto'], re.IGNORECASE)
                for patron in respaldos_aceptables
            )

            assert tiene_respaldo_aceptable

import json

class SuiteTestRegresion:
    def __init__(self, chatbot, ruta_dataset_dorado):
        self.chatbot = chatbot
        with open(ruta_dataset_dorado) as f:
            self.dataset_dorado = json.load(f)

    def ejecutar_tests_regresion(self):
        regresiones = []

        for caso_prueba in self.dataset_dorado:
            respuesta_actual = self.chatbot.enviar_mensaje(caso_prueba['entrada'])

            if respuesta_actual['intencion'] != caso_prueba['intencion_esperada']:
                regresiones.append({
                    'tipo': 'regresion_intencion',
                    'entrada': caso_prueba['entrada'],
                    'esperado': caso_prueba['intencion_esperada'],
                    'actual': respuesta_actual['intencion']
                })

        return {
            'tests_totales': len(self.dataset_dorado),
            'regresiones': len(regresiones),
            'tasa_regresion': len(regresiones) / len(self.dataset_dorado),
            'detalles': regresiones
        }

const BotiumConnector = require('botium-connector-dialogflow')

describe('Chatbot de Reserva de Vuelos', function() {
  it('debería entender intención de reservar vuelo', async function() {
    await this.connector.UserSays('Quiero reservar un vuelo')
    const response = await (como se discute en [AI-Assisted Bug Triaging: Intelligent Defect Prioritization at Scale](/blog/ai-bug-triaging)) this.connector.WaitBotSays()

 (como se discute en [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection))    expect(response.intent).to.equal('reservar_vuelo')
  })
})