Pruebas de Interfaces de Voz: QA para la Era Conversacional

from voice_testing import SpeechRecognitionTester
import pytest

class TestSpeechRecognition:
    def setup_method(self):
        self.tester = SpeechRecognitionTester(
            service='alexa',
            locale='es-ES'
        )

    def test_clear_speech_recognition(self):
        """Probar reconocimiento con audio de calidad de estudio"""
        result = self.tester.recognize_audio(
            audio_file='test_data/clear_speech/encender_luces.wav',
            expected_text='enciende las luces'
        )

        assert result.accuracy >= 0.95
        assert result.word_error_rate <= 0.05

    @pytest.mark.parametrize('noise_type,snr', [
        ('white_noise', 10),
        ('traffic', 5),
        ('restaurant', 0),
        ('music', -5)
    ])
    def test_noisy_environment_recognition(self, noise_type, snr):
        """Probar reconocimiento con ruido de fondo en varios niveles SNR"""
        result = self.tester.recognize_with_noise(
            clean_audio='test_data/commands/poner_temporizador.wav',
            noise_type=noise_type,
            signal_to_noise_ratio=snr,
            expected_text='pon un temporizador de cinco minutos'
        )

        # Los criterios de aceptación varían según SNR
        if snr >= 5:
            assert result.accuracy >= 0.85
        elif snr >= 0:
            assert result.accuracy >= 0.70
        else:
            assert result.accuracy >= 0.50

const VoiceTester = require('voice-qa-framework');

describe('Pruebas de Reconocimiento de Acentos', () => {
  const tester = new VoiceTester({
    platform: 'google-assistant',
    language: 'es'
  });

  const accents = [
    { name: 'Castellano España', audio: 'test_data/accents/es_spain.wav' },
    { name: 'Mexicano', audio: 'test_data/accents/es_mexico.wav' },
    { name: 'Argentino', audio: 'test_data/accents/es_argentina.wav' },
    { name: 'Colombiano', audio: 'test_data/accents/es_colombia.wav' },
    { name: 'Chileno', audio: 'test_data/accents/es_chile.wav' }
  ];

  accents.forEach(accent => {
    it(`debería reconocer acento "${accent.name}"`, async () => {
      const result = await tester.recognizeSpeech({
        audioFile: accent.audio,
        expectedTranscript: 'cómo está el clima hoy',
        tolerance: 0.15  // Permitir 15% de tasa de error de palabras
      });

      expect(result.recognized).toBe(true);
      expect(result.wordErrorRate).toBeLessThan(0.15);

      // Registrar para seguimiento de rendimiento de acentos
      await tester.logMetric({
        metric: 'accent_accuracy',
        accent: accent.name,
        wer: result.wordErrorRate
      });
    });
  });
});

from nlu_testing import IntentTester

class TestIntentRecognition:
    def setup_method(self):
        self.tester = IntentTester(
            nlu_model='skill_handler_v2',
            confidence_threshold=0.75
        )

    def test_single_intent_variations(self):
        """Probar reconocimiento de intenciones a través de variaciones de lenguaje natural"""
        test_cases = [
            # Intención: set_timer
            ("pon un temporizador de 5 minutos", "set_timer", {"duration": "5 minutos"}),
            ("inicia un temporizador de 5 minutos", "set_timer", {"duration": "5 minutos"}),
            ("temporizador para cinco minutos por favor", "set_timer", {"duration": "5 minutos"}),
            ("recuérdame en 5 minutos", "set_timer", {"duration": "5 minutos"}),

            # Intención: play_music
            ("pon algo de jazz", "play_music", {"genre": "jazz"}),
            ("quiero escuchar música jazz", "play_music", {"genre": "jazz"}),
            ("reproduce jazz", "play_music", {"genre": "jazz"}),
        ]

        for utterance, expected_intent, expected_slots in test_cases:
            result = self.tester.classify_intent(utterance)

            assert result.intent == expected_intent, \
                f"Falló en: '{utterance}' - obtuvo {result.intent}"
            assert result.confidence >= 0.75
            assert result.slots == expected_slots

    def test_ambiguous_intent_handling(self):
        """Probar manejo de expresiones ambiguas"""
        result = self.tester.classify_intent("pon algo")

        # Debería pedir aclaración o hacer una suposición razonable
        assert (
            result.intent == "clarification_needed" or
            (result.intent == "play_music" and result.confidence >= 0.65)
        )

import com.voiceqa.ConversationTester;
import org.junit.jupiter.api.Test;

public class MultiTurnConversationTest {
    private ConversationTester tester = new ConversationTester("alexa-skill-pizza-order");

    @Test
    public void testPizzaOrderingConversation() {
        // Turno 1: Inicio de intención
        ConversationState state = tester.startConversation();
        Response response1 = state.sendUtterance("quiero pedir una pizza");

        assertEquals("order_pizza", response1.getIntent());
        assertTrue(response1.getSpeech().contains("qué tamaño"));

        // Turno 2: Proporcionar tamaño
        Response response2 = state.sendUtterance("grande");

        assertEquals("order_pizza.provide_size", response2.getIntent());
        assertEquals("grande", state.getSlot("size"));
        assertTrue(response2.getSpeech().contains("ingredientes"));

        // Turno 3: Proporcionar ingredientes
        Response response3 = state.sendUtterance("pepperoni y champiñones");

        assertEquals(List.of("pepperoni", "champiñones"), state.getSlot("toppings"));
        assertTrue(response3.getSpeech().contains("confirmar"));

        // Turno 4: Confirmar pedido
        Response response4 = state.sendUtterance("sí confirmar");

        assertEquals("order_confirmed", response4.getIntent());
        assertTrue(state.isConversationComplete());

        // Verificar que el contexto de la conversación se mantuvo
        assertEquals("grande", state.getFinalSlot("size"));
        assertNotNull(state.getFinalSlot("order_id"));
    }
}

import pandas as pd
from voice_testing import MultilingualTester

class TestMultilingualSupport:
    LANGUAGES = ['es-ES', 'es-MX', 'es-AR', 'en-US', 'pt-BR', 'fr-FR', 'de-DE', 'it-IT']

    def test_command_recognition_all_languages(self):
        """Probar comandos básicos en todos los idiomas soportados"""
        tester = MultilingualTester()

        commands = {
            'es-ES': 'enciende las luces',
            'es-MX': 'prende las luces',
            'es-AR': 'prendé las luces',
            'en-US': 'turn on the lights',
            'pt-BR': 'acenda as luzes',
            'fr-FR': 'allume les lumières',
            'de-DE': 'schalte das licht ein',
            'it-IT': 'accendi le luci'
        }

        results = []

        for lang, command in commands.items():
            audio_file = f'test_data/multilingual/{lang}/lights_on.wav'
            result = tester.test_command(
                locale=lang,
                audio_file=audio_file,
                expected_intent='turn_on_lights',
                expected_text=command
            )

            results.append({
                'language': lang,
                'accuracy': result.accuracy,
                'latency_ms': result.latency_ms,
                'intent_confidence': result.intent_confidence
            })

        df = pd.DataFrame(results)
        print(df)

        assert df['accuracy'].min() >= 0.85, "Algunos idiomas por debajo del umbral de precisión"
        assert df['latency_ms'].mean() <= 500, "Latencia promedio muy alta"

# Ejemplo de integración CI/CD
voice-test-suite run \
  --platform alexa \
  --test-suite regression \
  --locales es-ES,es-MX,es-AR \
  --parallel 10 \
  --report junit \
  --threshold accuracy=0.90

# Monitoreo de producción
voice_metrics.track({
    'intent_accuracy': intent_match_rate,
    'average_wer': weekly_wer,
    'p95_latency': latency_p95,
    'user_satisfaction': explicit_feedback_score
})