python-testing

name python-testing description Estrategias de pruebas Python usando pytest, metodología TDD, fixtures, mocking, parametrización y requisitos de cobertura. origin ECC Patrones de Pruebas Python Estrategias completas de pruebas para aplicaciones Python usando pytest, metodología TDD y buenas prácticas. Cuándo Activar Escribir código Python nuevo (seguir TDD: rojo, verde, refactorizar) Diseñar suites de pruebas para proyectos Python Revisar la cobertura de pruebas Python Configurar infraestructura de pruebas Filosofía Central de Pruebas Desarrollo Guiado por Pruebas (TDD) Siempre seguir el ciclo TDD: ROJO : Escribir una prueba que falle para el comportamiento deseado VERDE : Escribir el código mínimo para que la prueba pase REFACTORIZAR : Mejorar el código manteniendo las pruebas en verde # Paso 1: Escribir prueba fallida (ROJO) def test_add_numbers (): result = add( 2 , 3 ) assert result == 5 # Paso 2: Escribir implementación mínima (VERDE) def add ( a, b ): return a + b # Paso 3: Refactorizar si es necesario (REFACTORIZAR) Requisitos de Cobertura Objetivo : 80%+ de cobertura de código Rutas críticas : 100% de cobertura requerida Usar pytest --cov para medir la cobertura pytest --cov=mypackage --cov-report=term-missing --cov-report=html Fundamentos de pytest Estructura Básica de Pruebas import pytest def test_addition (): """Prueba la suma básica.""" assert 2 + 2 == 4 def test_string_uppercase (): """Prueba la conversión a mayúsculas.""" text = "hello" assert text.upper() == "HELLO" def test_list_append (): """Prueba el append de lista.""" items = [ 1 , 2 , 3 ] items.append( 4 ) assert 4 in items assert len (items) == 4 Aserciones # Igualdad assert result == expected # Desigualdad assert result != unexpected # Veracidad assert result # Truthy assert not result # Falsy assert result is True # Exactamente True assert result is False # Exactamente False assert result is None # Exactamente None # Membresía assert item in collection assert item not in collection # Comparaciones assert result > 0 assert 0 <= result <= 100 # Verificación de tipo assert isinstance (result, str ) # Prueba de excepción (enfoque preferido) with pytest.raises(ValueError): raise ValueError( "mensaje de error" ) # Verificar mensaje de excepción with pytest.raises(ValueError, match = "entrada inválida" ): raise ValueError( "entrada inválida proporcionada" ) Fixtures Uso Básico de Fixtures import pytest @pytest.fixture def sample_data (): """Fixture que proporciona datos de ejemplo.""" return { "name" : "Alice" , "age" : 30 } def test_sample_data ( sample_data ): """Prueba usando el fixture.""" assert sample_data[ "name" ] == "Alice" assert sample_data[ "age" ] == 30 Fixture con Setup/Teardown @pytest.fixture def database (): """Fixture con setup y teardown.""" # Setup db = Database( ":memory:" ) db.create_tables() db.insert_test_data() yield db # Proporcionar a la prueba # Teardown db.close() def test_database_query ( database ): """Prueba operaciones de base de datos.""" result = database.query( "SELECT * FROM users" ) assert len (result) > 0 Alcances de Fixtures # Alcance de función (por defecto) - se ejecuta por cada prueba @pytest.fixture def temp_file (): with open ( "temp.txt" , "w" ) as f: yield f os.remove( "temp.txt" ) # Alcance de módulo - se ejecuta una vez por módulo @pytest.fixture( scope= "module" ) def module_db (): db = Database( ":memory:" ) db.create_tables() yield db db.close() # Alcance de sesión - se ejecuta una vez por sesión de pruebas @pytest.fixture( scope= "session" ) def shared_resource (): resource = ExpensiveResource() yield resource resource.cleanup() Fixture con Parámetros @pytest.fixture( params=[ 1 , 2 , 3 ] ) def number ( request ): """Fixture parametrizado.""" return request.param def test_numbers ( number ): """La prueba se ejecuta 3 veces, una por cada parámetro.""" assert number > 0 Fixtures Autouse @pytest.fixture( autouse= True ) def reset_config (): """Se ejecuta automáticamente antes de cada prueba.""" Config.reset() yield Config.cleanup() def test_without_fixture_call (): # reset_config se ejecuta automáticamente assert Config.get_setting( "debug" ) is False Conftest.py para Fixtures Compartidos # tests/conftest.py import pytest @pytest.fixture def client (): """Fixture compartido para todas las pruebas.""" app = create_app(testing= True ) with app.test_client() as client: yield client @pytest.fixture def auth_headers ( client ): """Genera cabeceras de autenticación para pruebas de API.""" response = client.post( "/api/login" , json={ "username" : "test" , "password" : "test" }) token = response.json[ "token" ] return { "Authorization" : f"Bearer {token} " } Parametrización Parametrización Básica @pytest.mark.parametrize( "input,expected" , [ ( "hello" , "HELLO" ), ( "world" , "WORLD" ), ( "PyThOn" , "PYTHON" ), ] ) def test_uppercase ( input , expected ): """La prueba se ejecuta 3 veces con diferentes entradas.""" assert input .upper() == expected Múltiples Parámetros @pytest.mark.parametrize( "a,b,expected" , [ ( 2 , 3 , 5 ), ( 0 , 0 , 0 ), ( - 1 , 1 , 0 ), ( 100 , 200 , 300 ), ] ) def test_add ( a, b, expected ): """Prueba la suma con múltiples entradas.""" assert add(a, b) == expected Parametrizar con IDs @pytest.mark.parametrize( "input,expected" , [ ( "valid@email.com" , True ), ( "invalid" , False ), ( "@no-domain.com" , False ), ], ids=[ "valid-email" , "missing-at" , "missing-domain" ] ) def test_email_validation ( input , expected ): """Prueba validación de email con IDs legibles.""" assert is_valid_email( input ) is expected Markers y Selección de Pruebas Markers Personalizados # Marcar pruebas lentas @pytest.mark.slow def test_slow_operation (): time.sleep( 5 ) # Marcar pruebas de integración @pytest.mark.integration def test_api_integration (): response = requests.get( "https://api.example.com" ) assert response.status_code == 200 # Marcar pruebas unitarias @pytest.mark.unit def test_unit_logic (): assert calculate( 2 , 3 ) == 5 Ejecutar Pruebas Específicas # Ejecutar solo pruebas rápidas pytest -m "not slow" # Ejecutar solo pruebas de integración pytest -m integration # Ejecutar pruebas de integración o lentas pytest -m "integration or slow" Configurar Markers en pytest.ini [pytest] markers = slow: marca pruebas como lentas integration: marca pruebas como de integración unit: marca pruebas como unitarias Mocking y Patching Mocking de Funciones from unittest.mock import patch, Mock @patch( "mypackage.external_api_call" ) def test_with_mock ( api_call_mock ): """Prueba con API externa mockeada.""" api_call_mock.return_value = { "status" : "success" } result = my_function() api_call_mock.assert_called_once() assert result[ "status" ] == "success" Mocking de Excepciones @patch( "mypackage.api_call" ) def test_api_error_handling ( api_call_mock ): """Prueba manejo de errores con excepción mockeada.""" api_call_mock.side_effect = ConnectionError( "Error de red" ) with pytest.raises(ConnectionError): api_call() api_call_mock.assert_called_once() Mocking de Context Managers @patch( "builtins.open" , new_callable=mock_open ) def test_file_reading ( mock_file ): """Prueba lectura de archivo con open mockeado.""" mock_file.return_value.read.return_value = "contenido del archivo" result = read_file( "test.txt" ) mock_file.assert_called_once_with( "test.txt" , "r" ) assert result == "contenido del archivo" Usar Autospec @patch( "mypackage.DBConnection" , autospec= True ) def test_autospec ( db_mock ): """Prueba con autospec para detectar mal uso de API.""" db = db_mock.return_value db.query( "SELECT * FROM users" ) db_mock.assert_called_once() Mock de Propiedades @pytest.fixture def mock_config (): """Crea un mock con una propiedad.""" config = Mock() type (config).debug = PropertyMock(return_value= True ) type (config).api_key = PropertyMock(return_value= "test-key" ) return config Pruebas de Código Asíncrono Pruebas Async con pytest-asyncio import pytest @pytest.mark.asyncio async def test_async_function (): """Prueba función async.""" result = await async_add( 2 , 3 ) assert result == 5 Fixture Async @pytest.fixture async def async_client (): """Fixture async que proporciona cliente de prueba async.""" app = create_app() async with app.test_client() as client: yield client Pruebas de Excepciones Probar Excepciones Esperadas def test_divide_by_zero (): """Prueba que dividir por cero lanza ZeroDivisionError.""" with pytest.raises(ZeroDivisionError): divide( 10 , 0 ) def test_custom_exception (): """Prueba excepción personalizada con mensaje.""" with pytest.raises(ValueError, match = "entrada inválida" ): validate_input( "invalid" ) Pruebas con tmp_path def test_with_tmp_path ( tmp_path ): """Prueba usando el fixture de ruta temporal de pytest.""" test_file = tmp_path / "test.txt" test_file.write_text( "hello world" ) result = process_file( str (test_file)) assert result == "hello world" # tmp_path se limpia automáticamente Organización de Pruebas Estructura de Directorio tests/ ├── conftest.py # Fixtures compartidos ├── __init__.py ├── unit/ # Pruebas unitarias │ ├── __init__.py │ ├── test_models.py │ ├── test_utils.py │ └── test_services.py ├── integration/ # Pruebas de integración │ ├── __init__.py │ ├── test_api.py │ └── test_database.py └── e2e/ # Pruebas end-to-end ├── __init__.py └── test_user_flow.py Clases de Prueba class TestUserService : """Agrupa pruebas relacionadas en una clase.""" @pytest.fixture( autouse= True ) def setup ( self ): """Setup se ejecuta antes de cada prueba en esta clase.""" self .service = UserService() def test_create_user ( self ): """Prueba creación de usuario.""" user = self .service.create_user( "Alice" ) assert user.name == "Alice" def test_delete_user ( self ): """Prueba eliminación de usuario.""" user = User( id = 1 , name= "Bob" ) self .service.delete_user(user) assert not self .service.user_exists( 1 ) Buenas Prácticas HACER