Тестирование Голосовых Интерфейсов: QA для Эры Разговоров

from voice_testing import SpeechRecognitionTester
import pytest

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

    def test_clear_speech_recognition(self):
        """Тест распознавания с аудио студийного качества"""
        result = self.tester.recognize_audio(
            audio_file='test_data/clear_speech/включи_свет.wav',
            expected_text='включи свет'
        )

        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):
        """Тест распознавания с фоновым шумом на различных уровнях SNR"""
        result = self.tester.recognize_with_noise(
            clean_audio='test_data/commands/поставь_таймер.wav',
            noise_type=noise_type,
            signal_to_noise_ratio=snr,
            expected_text='поставь таймер на пять минут'
        )

        # Критерии приемки варьируются в зависимости от 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('Тесты Распознавания Акцентов', () => {
  const tester = new VoiceTester({
    platform: 'google-assistant',
    language: 'ru'
  });

  const accents = [
    { name: 'Московский', audio: 'test_data/accents/ru_moscow.wav' },
    { name: 'Санкт-Петербургский', audio: 'test_data/accents/ru_spb.wav' },
    { name: 'Южный', audio: 'test_data/accents/ru_south.wav' },
    { name: 'Уральский', audio: 'test_data/accents/ru_ural.wav' },
    { name: 'Сибирский', audio: 'test_data/accents/ru_siberia.wav' }
  ];

  accents.forEach(accent => {
    it(`должен распознавать акцент "${accent.name}"`, async () => {
      const result = await tester.recognizeSpeech({
        audioFile: accent.audio,
        expectedTranscript: 'какая погода сегодня',
        tolerance: 0.15  // Разрешить 15% ошибок в словах
      });

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

      // Логирование для отслеживания производительности акцентов
      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):
        """Тест распознавания интентов через вариации естественного языка"""
        test_cases = [
            # Интент: set_timer
            ("поставь таймер на 5 минут", "set_timer", {"duration": "5 минут"}),
            ("запусти таймер на 5 минут", "set_timer", {"duration": "5 минут"}),
            ("таймер на пять минут пожалуйста", "set_timer", {"duration": "5 минут"}),
            ("напомни мне через 5 минут", "set_timer", {"duration": "5 минут"}),

            # Интент: play_music
            ("включи джаз", "play_music", {"genre": "джаз"}),
            ("я хочу послушать джаз", "play_music", {"genre": "джаз"}),
            ("поставь джазовую музыку", "play_music", {"genre": "джаз"}),
        ]

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

            assert result.intent == expected_intent, \
                f"Провал на: '{utterance}' - получено {result.intent}"
            assert result.confidence >= 0.75
            assert result.slots == expected_slots

    def test_ambiguous_intent_handling(self):
        """Тест обработки неоднозначных высказываний"""
        result = self.tester.classify_intent("включи что-нибудь")

        # Должен либо запросить уточнение, либо сделать разумное предположение
        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() {
        // Шаг 1: Инициация интента
        ConversationState state = tester.startConversation();
        Response response1 = state.sendUtterance("я хочу заказать пиццу");

        assertEquals("order_pizza", response1.getIntent());
        assertTrue(response1.getSpeech().contains("какой размер"));

        // Шаг 2: Указать размер
        Response response2 = state.sendUtterance("большую");

        assertEquals("order_pizza.provide_size", response2.getIntent());
        assertEquals("большая", state.getSlot("size"));
        assertTrue(response2.getSpeech().contains("начинк"));

        // Шаг 3: Указать начинку
        Response response3 = state.sendUtterance("пепперони и грибы");

        assertEquals(List.of("пепперони", "грибы"), state.getSlot("toppings"));
        assertTrue(response3.getSpeech().contains("подтверд"));

        // Шаг 4: Подтвердить заказ
        Response response4 = state.sendUtterance("да подтверждаю");

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

        // Проверить, что контекст разговора сохранен
        assertEquals("большая", state.getFinalSlot("size"));
        assertNotNull(state.getFinalSlot("order_id"));
    }
}

import pandas as pd
from voice_testing import MultilingualTester

class TestMultilingualSupport:
    LANGUAGES = ['ru-RU', 'en-US', 'es-ES', 'de-DE', 'fr-FR', 'zh-CN', 'ja-JP', 'ar-SA']

    def test_command_recognition_all_languages(self):
        """Тест базовых команд на всех поддерживаемых языках"""
        tester = MultilingualTester()

        commands = {
            'ru-RU': 'включи свет',
            'en-US': 'turn on the lights',
            'es-ES': 'enciende las luces',
            'de-DE': 'schalte das licht ein',
            'fr-FR': 'allume les lumières',
            'zh-CN': '打开灯',
            'ja-JP': '電気をつけて',
            'ar-SA': 'أشعل الأضواء'
        }

        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, "Некоторые языки ниже порога точности"
        assert df['latency_ms'].mean() <= 500, "Средняя латентность слишком высокая"

# Пример интеграции CI/CD
voice-test-suite run \
  --platform alexa \
  --test-suite regression \
  --locales ru-RU,en-US,es-ES \
  --parallel 10 \
  --report junit \
  --threshold accuracy=0.90

# Мониторинг продакшена
voice_metrics.track({
    'intent_accuracy': intent_match_rate,
    'average_wer': weekly_wer,
    'p95_latency': latency_p95,
    'user_satisfaction': explicit_feedback_score
})