Probar Tu Integración

Aprende cómo probar exhaustivamente tu integración con CallCov antes de pasar a producción.

Resumen

CallCov proporciona un entorno de prueba completo para validar tu integración:

• Claves API de prueba - Claves separadas para testing (prefijo: sk_test_)
• Modo de prueba - Procesamiento simulado sin cargos
• Archivos de audio de muestra - Datos de prueba preconfigurados
• Resultados determinísticos - Respuestas predecibles para testing automatizado

Claves de Prueba vs Producción

Obtener Claves de Prueba

Las claves de prueba están disponibles en tu dashboard bajo "API Keys" → "Test Mode":

# Test key (siempre comienza con sk_test_)
export CALLCOV_API_KEY_TEST="sk_test_abc123..."

# Production key (comienza con sk_live_)
export CALLCOV_API_KEY_PROD="sk_live_xyz789..."

Diferencias Clave

Característica	Modo de Prueba (sk_test_)	Producción (sk_live_)
Facturación	Gratis, sin cargos	Facturación medida
Procesamiento	Simulado (instantáneo)	Análisis real con IA
Límites de Rate	10 req/seg	100 req/seg
Webhooks	Entregados normalmente	Entregados normalmente
Retención de Datos	7 días	Configurable

Unit Testing

Probar Cliente API

Prueba tu wrapper de cliente API con respuestas simuladas:

import unittest
from unittest.mock import patch, Mock
from your_app.callcov_client import CallCovClient

class TestCallCovClient(unittest.TestCase):

  def setUp(self):
      self.client = CallCovClient(api_key="sk_test_mock")

  @patch('requests.post')
  def test_submit_analysis_success(self, mock_post):
      # Mock successful response
      mock_response = Mock()
      mock_response.status_code = 201
      mock_response.json.return_value = {
          'id': 'analysis_123',
          'status': 'processing',
          'created': 1234567890
      }
      mock_post.return_value = mock_response

      # Test submission
      result = self.client.submit_analysis('https://example.com/call.wav')

      # Assertions
      self.assertEqual(result['id'], 'analysis_123')
      self.assertEqual(result['status'], 'processing')
      mock_post.assert_called_once()

  @patch('requests.post')
  def test_submit_analysis_with_invalid_url(self, mock_post):
      # Mock error response
      mock_response = Mock()
      mock_response.status_code = 400
      mock_response.json.return_value = {
          'error': {
              'type': 'invalid_request',
              'message': 'Invalid audio URL'
          }
      }
      mock_post.return_value = mock_response

      # Test error handling
      with self.assertRaises(ValueError):
          self.client.submit_analysis('invalid-url')

  @patch('requests.get')
  def test_get_analysis_results(self, mock_get):
      # Mock completed analysis
      mock_response = Mock()
      mock_response.status_code = 200
      mock_response.json.return_value = {
          'id': 'analysis_123',
          'status': 'completed',
          'results': {
              'compliance': {'overall_score': 0.95},
              'quality': {'overall_score': 0.88}
          }
      }
      mock_get.return_value = mock_response

      # Test retrieval
      result = self.client.get_analysis('analysis_123')

      # Assertions
      self.assertEqual(result['status'], 'completed')
      self.assertEqual(result['results']['compliance']['overall_score'], 0.95)

if __name__ == '__main__':
  unittest.main()

Pruebas de Integración

Prueba con la API Real (Modo de Prueba)

Las pruebas de integración usan llamadas reales a la API con claves de prueba:

import unittest
import os
from your_app.callcov_client import CallCovClient

class TestCallCovIntegration(unittest.TestCase):

  @classmethod
  def setUpClass(cls):
      # Use test API key
      cls.client = CallCovClient(
          api_key=os.getenv('CALLCOV_API_KEY_TEST')
      )

  def test_full_analysis_workflow(self):
      """Test complete workflow: submit -> poll -> retrieve results"""

      # Step 1: Submit analysis with test audio
      submission = self.client.submit_analysis(
          audio_url='https://callcov-test-data.s3.amazonaws.com/sample-call.wav',
          agent_id='test_agent_001'
      )

      self.assertIn('id', submission)
      self.assertEqual(submission['status'], 'processing')
      analysis_id = submission['id']

      # Step 2: Wait for completion (test mode is instant)
      import time
      time.sleep(2)  # Brief delay for async processing

      # Step 3: Retrieve results
      results = self.client.get_analysis(analysis_id)

      self.assertEqual(results['status'], 'completed')
      self.assertIn('results', results)
      self.assertIn('compliance', results['results'])
      self.assertIn('quality', results['results'])

  def test_webhook_delivery(self):
      """Test webhook is triggered on completion"""

      webhook_url = 'https://webhook.site/your-unique-id'

      submission = self.client.submit_analysis(
          audio_url='https://callcov-test-data.s3.amazonaws.com/sample-call.wav',
          webhook_url=webhook_url
      )

      # In test mode, webhook fires immediately
      time.sleep(3)

      # Verify webhook was received (check webhook.site)
      # In real tests, you'd verify via your webhook endpoint logs

  def test_error_handling(self):
      """Test API returns appropriate errors"""

      # Test invalid audio URL
      with self.assertRaises(Exception) as context:
          self.client.submit_analysis(audio_url='not-a-url')

      self.assertIn('invalid', str(context.exception).lower())

  def test_pagination(self):
      """Test paginated results"""

      # Submit multiple analyses
      analysis_ids = []
      for i in range(5):
          result = self.client.submit_analysis(
              audio_url='https://callcov-test-data.s3.amazonaws.com/sample-call.wav',
              agent_id=f'test_agent_{i:03d}'
          )
          analysis_ids.append(result['id'])

      # Retrieve with pagination
      page1 = self.client.list_analyses(limit=3)
      self.assertEqual(len(page1['data']), 3)
      self.assertTrue(page1['has_more'])

      page2 = self.client.list_analyses(
          limit=3,
          starting_after=page1['data'][-1]['id']
      )
      self.assertEqual(len(page2['data']), 2)

Datos de Prueba y Fixtures

Archivos de Audio de Muestra

CallCov proporciona archivos de audio de prueba para testing consistente:

# Sample files available in test mode
https://callcov-test-data.s3.amazonaws.com/sample-call.wav
https://callcov-test-data.s3.amazonaws.com/sample-compliance-violation.wav
https://callcov-test-data.s3.amazonaws.com/sample-poor-quality.wav
https://callcov-test-data.s3.amazonaws.com/sample-excellent-call.wav

Mejores Prácticas de Testing

1. Usa Modo de Prueba para Desarrollo

Siempre usa claves de prueba durante el desarrollo:

import os

# Environment-based configuration
if os.getenv('ENVIRONMENT') == 'production':
    API_KEY = os.getenv('CALLCOV_API_KEY_PROD')
else:
    API_KEY = os.getenv('CALLCOV_API_KEY_TEST')

2. Simula Dependencias Externas

Simula la API de CallCov para pruebas unitarias rápidas:

from unittest.mock import patch

@patch('your_app.callcov_client.requests.post')
def test_fast_unit_test(mock_post):
    """Unit test doesn't hit real API"""
    mock_post.return_value.json.return_value = {'id': 'mock_id'}

    result = submit_analysis('http://example.com/call.wav')
    assert result['id'] == 'mock_id'

3. Prueba Escenarios de Error

No solo pruebes los caminos felices:

def test_error_scenarios():
    """Test various failure modes"""

    # Network timeout
    with pytest.raises(TimeoutError):
        client.submit_analysis('https://example.com/call.wav', timeout=0.001)

    # Invalid API key
    bad_client = CallCovClient(api_key='sk_test_invalid')
    with pytest.raises(AuthenticationError):
        bad_client.submit_analysis('https://example.com/call.wav')

    # Rate limit exceeded
    # (In test mode, simulate by rapid requests)
    for i in range(20):
        try:
            client.submit_analysis('https://example.com/call.wav')
        except RateLimitError:
            # Expected after ~10 requests in test mode
            break

4. Limpia Datos de Prueba

Elimina análisis de prueba después de testing:

def tearDown(self):
    """Clean up test analyses"""
    # Delete any analyses created during testing
    for analysis_id in self.created_analysis_ids:
        try:
            self.client.delete_analysis(analysis_id)
        except:
            pass  # Already deleted or doesn't exist

5. Usa CI/CD para Testing Automatizado

Ejecuta pruebas automáticamente en cada commit:

# .github/workflows/test.yml
name: Test CallCov Integration

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.9'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Run tests
        env:
          CALLCOV_API_KEY_TEST: ${{ secrets.CALLCOV_API_KEY_TEST }}
        run: pytest tests/

Transición a Producción

Checklist Pre-Lanzamiento

Antes de cambiar a claves de producción:

• Todas las pruebas pasando con claves de prueba
• Manejo de errores probado para todos los escenarios
• Endpoint de webhook probado y verificado
• Rate limiting implementado
• Logging y monitoreo configurado
• Estimación de costos completada
• Revisión de seguridad completada
• Documentación actualizada

Cambiar a Producción

# config.py
import os

class Config:
    def __init__(self):
        self.environment = os.getenv('ENVIRONMENT', 'development')

        if self.environment == 'production':
            self.api_key = os.getenv('CALLCOV_API_KEY_PROD')
            self.webhook_url = 'https://api.yourapp.com/webhooks/callcov'
        else:
            self.api_key = os.getenv('CALLCOV_API_KEY_TEST')
            self.webhook_url = 'https://webhook.site/test-id'

    def is_production(self):
        return self.environment == 'production'

Próximos Pasos

• Guía de Autenticación - Configura las claves API correctamente
• Manejo de Errores - Maneja errores en producción
• Mejores Prácticas de Producción - Optimiza para producción
• Webhooks - Configura endpoints de webhook confiables