Arquitectura General del Entorno de Pruebas

SublimeWebInspector implementa un diseño de pruebas modular que distribuye la lógica de validación en múltiples archivos especializados. Esta estrategia garantiza que el código de prueba sea fácilmente mantenible y extensible. Los componentes principales residen en el directorio tests/ del proyecto e incluyen:

• Punto de entrada de ejecución: TestCoordinator.py
• Validación de mapas de origen: SourcemapTests.py
• Validación de mapeo de documentos: DocumentMappingTests.py
• Scripts de automatización: execute_tests.sh (Linux/macOS) y executeTests.bat (Windows)

Esta separación permite a los deasrrolladores crear pruebas independientes para módulos específicos, orquestando su ejecución masiva a través de un único punto de entrada.

Diseño de Pruebas Unitarias

El sistema de pruebas unitarias se basa en el framework estándar unittest de Python. Cada clase de prueba tiene la responsabilidad de verificar la corrección funcional de un módulo particular. En el contexto de los mapas de origen, el archivo SourcemapTests.py agrupa tres clases fundamentales:

1. MapParserValidation: Evalúa la lógica de lectura y parseo de archivos de mapeo.
2. ParsedMapBehavior: Comprueba el comportamiento de los objetos una vez procesados.
3. LineMappingAccuracy: Verifica la precisión de los algoritmos de búsqueda de líneas.

Los métodos de prueba siguen la convención de nomenclatura con el prefijo test_. A continuación, se muestra una implementación reestructurada:

import unittest
import Sourcemap

class MapParserValidation(unittest.TestCase):
    def test_missing_file_handling(self):
        # Verify that a missing file is handled gracefully without raising exceptions
        processor = Sourcemap.SourceMapParser()
        processor.parse(f"{FIXTURES_DIR}missing_map.js.map")
        
    def test_map_version_validation(self):
        # Ensure the source map version is correctly identified
        processor = Sourcemap.SourceMapParser()
        processor.parse(f"{FIXTURES_DIR}bundle.js.map")
        self.assertEqual(processor.version, 3)

Estrategias para Condiciones Límite

Un entorno de pruebas robusto debe evaluar tanto el flujo estándar como los escenarios de error. El framework aborda esto mediante casos específicos:

• Entradas inválidas: Métodos agrupados bajo test_invalid_input verifican la tolerancia a fallos ante datos malformados.
• Simulación de excepciones: Pruebas como test_missing_file_handling aseguran que la aplicación degrade su funcionalidad de manera controlada si un recurso no existe.
• Validación de tipos: Casos como test_zero_based_position comprueban la exactitud matemática en el cálculo de coordenadas.

Implementación de Pruebas de Integración

Para evaluar la interacción entre diferentes componentes, TestCoordinator.py actúa como el orquestador principle. Mediante una función auxiliar, los suites de prueba se cargan y ejecutan de manera secuencial:

def execute_test_suite(test_class):
    print(f"Executing test suite: {test_class.__name__}")
    test_suite = unittest.TestLoader().loadTestsFromTestCase(test_class)
    unittest.TextTestRunner(verbosity=2).run(test_suite)

# Source map parsing tests
execute_test_suite(SourcemapTests.MapParserValidation)
execute_test_suite(SourcemapTests.ParsedMapBehavior)
execute_test_suite(SourcemapTests.LineMappingAccuracy)

# Document mapping tests
execute_test_suite(DocumentMappingTests.CoordinateTests)
execute_test_suite(DocumentMappingTests.MappingDataTests)
execute_test_suite(DocumentMappingTests.MappingCoordinatorTests)

Gestión de Recursos de Prueba

Los datos de entrada requeridos para las validaciones se almacenan de forma centralizada en el directorio tests/fixtures/. Este repositorio incluye:

• bundle.js: Archivo JavaScript de referencia.
• bundle.js.map: El mapa de origen correspondiente.
• malformed.json: Archivos con formatos específicos para pruebas de error.

La ruta absoluta a estos recursos se resuelve dinámicamente en tiempo de ejecución:

import os

# Test fixtures directory resolution
FIXTURES_DIR = os.path.join(os.path.abspath("tests"), "fixtures").lower() + os.path.sep

Ejecución del Entorno

El framework proporciona scripts nativos para desencadenar el proceso de validación en diferentes sistemas operativos:

Entornos Unix (Linux/macOS):

# Unix-based execution
./tests/execute_tests.sh

Entornos Windows:

:: Windows execution
tests\executeTests.bat

Internamente, estos scripts invocan al intérprete de Python para procesar el archivo de orquestación:

# Inside the shell script:
SCRIPT_DIR=$(dirname "$0")
$PYTHON_EXEC "$SCRIPT_DIR/TestCoordinator.py"

Aálisis de Resultados

Al finalizar la ejecución, la consola emite un reporte detallado que incluye el estado de cada caso y el tiempo de procesamiento:

Executing test suite: MapParserValidation
test_line_mapping_count (SourcemapTests.MapParserValidation) ... ok
test_missing_file_handling (SourcemapTests.MapParserValidation) ... ok
test_valid_json_invalid_map_does_not_throw (SourcemapTests.MapParserValidation) ... ok
test_map_version_validation (SourcemapTests.MapParserValidation) ... ok

----------------------------------------------------------------------
Ran 4 tests in 0.002s

OK

Este nivel de detalle permite a los desarrolladores identificar rápidamente las rutas de fallo y depurar las interacciones entre los analizadores sintácticos y los archivos de mapeo.