Un campo de edad que acepta entre 18 y 60 años tiene una enorme cantidad de entradas posibles, una vez que se cuentan los negativos, los números enormes, el texto y los espacios en blanco. Nadie puede probarlos todos. La partición de equivalencia resuelve esto agrupando las entradas que el software debe tratar de la misma manera y luego probando un valor de cada grupo.

Es una de las primeras técnicas de diseño de pruebas que todo evaluador debería aprender. En esta guía lo analizamos paso a paso y probamos un ejemplo en Python. Ejecutamos ese código en Python 3.13 y se incluye su resultado. Las reglas de contraseñas y cupones que aparecen a continuación son ejemplos ilustrativos, no tomados de un sistema real.

¿Qué es la partición de equivalencia?

La partición de equivalencia, también llamada partición de clases de equivalencia (ECP), es una técnica de diseño de pruebas de caja negra. Divide las posibles entradas de una característica en particiones o clases. Se espera que cada valor dentro de una partición produzca el mismo tipo de comportamiento.

Como no necesita ver el código, puede aplicarlo directamente desde un requisito. Para obtener más información sobre este estilo de prueba, lea prueba de caja negra versus prueba de caja blanca.

Por que funciona

La técnica se basa en una suposición: si un valor en una partición encuentra un error, los demás en esa partición probablemente también lo encontrarán. Y si un valor se aprueba, los demás probablemente también se aprobarán. Es probable que realizar pruebas a 25, 26 y 27 años en un campo de edad adulta no le diga nada que la prueba a 25 por sí sola no le diga.

Sin embargo, es una suposición y no una garantía. El software puede tener casos especiales ocultos dentro de una partición, una limitación a la que volveremos más adelante.

Cómo hacerlo en cinco pasos

1. Lea el requisito e identifique la entrada y sus reglas.
2. Encuentre las particiones válidas, cuáles son los grupos de valores que deben aceptarse y observe si diferentes rangos se comportan de manera diferente.
3. Encuentre las particiones no válidas, incluidos valores demasiado bajos, demasiado altos, del tipo incorrecto y en blanco.
4. Elija un valor representativo de cada partición, generalmente en algún punto intermedio.
5. Escriba el resultado esperado para cada uno, como en cualquier buen caso de prueba.

Ejemplo resuelto: un campo de edad

Requisito: Pueden registrarse usuarios de entre 18 y 60 años.

Cinco pruebas le brindan cobertura de cada comportamiento del requisito. Muchos tutoriales se detienen en las tres primeras filas, pero las dos últimas son las que los usuarios reales activan por accidente. También puede agregar filas para números negativos o decimales, si es razonable manejarlos de manera diferente.

Probándolo en código

Aquí está esa regla como una función, con una prueba unitaria por partición, usando la función incorporada de Python unittest:

import unittest

def can_register(age):
    if not isinstance(age, int) or isinstance(age, bool):
        raise TypeError("age must be a whole number")
    return 18 <= age <= 60

class EquivalenceTests(unittest.TestCase):
    def test_valid_partition(self):
        self.assertTrue(can_register(35))

    def test_too_young_partition(self):
        self.assertFalse(can_register(10))

    def test_too_old_partition(self):
        self.assertFalse(can_register(75))

    def test_wrong_type_partition(self):
        with self.assertRaises(TypeError):
            can_register("abc")

Nuestra carrera pasó:

test_too_old_partition ... ok
test_too_young_partition ... ok
test_valid_partition ... ok
test_wrong_type_partition ... ok

En un proyecto real, la función de parametrización de pytest es una forma sencilla de ejecutar una tabla de valores de partición a través de una única prueba.

Ejemplo resuelto: una contraseña

Requisito: Una contraseña debe tener entre 8 y 20 caracteres y contener al menos un dígito.

Este tiene dos reglas, longitud y contenido, por lo que consideramos particiones para ambas:

Tenga en cuenta que cada prueba no válida infringe sólo una regla. Si un valor era demasiado corto y le faltaba un dígito, una prueba aprobada no podría indicarle qué verificación funcionó. Un cheque puede estar roto, mientras que el otro oculta el hecho.

Ejemplo resuelto: entradas no numéricas

La técnica no se limita a rangos de números. Las opciones, categorías y estados discretos también forman particiones. Supongamos que una tienda tiene esta regla:

Requisito: La entrega es gratuita para los miembros Gold, 50 para los Silver y 100 para todos los demás. Los valores de nivel desconocidos son errores.

Aquí, cada opción es su propia partición, ya que cada una debería comportarse de manera diferente. Otras particiones comunes incluyen tipos de archivos, como cargas válidas e inválidas, y grupos basados ​​en resultados, como un préstamo aprobado o rechazado.

Varias entradas a la vez

Con múltiples campos, la cantidad de combinaciones crece rápidamente. Tres campos con cuatro particiones cada uno dan 64 combinaciones. Dos estrategias ayudan:

• Cobertura débil: asegúrese de que cada partición aparezca en al menos una prueba, combinando varios valores válidos por prueba. Para valores no válidos, pruebe uno a la vez para que los errores no se enmascaren entre sí.
• Cobertura basada en reglas: cuando las combinaciones realmente cambian el resultado, como el estado del miembro con el valor del pedido, utilice pruebas de tabla de decisiones para enumerarlas correctamente.

Emparejamiento con análisis de valores límite

La partición le indica qué grupos probar. Dice poco sobre dónde en un grupo a los insectos les gusta esconderse, y muchos se esconden justo en los bordes. Para mostrar esto, escribimos una versión con errores con el clásico error de uno por uno:

def buggy(age):
    return 18 < age <= 60     # should be 18 <= age

[buggy(a) for a in (35, 10, 75)]   # [True, False, False]
buggy(18)                          # False

Nuestros valores de partición, 35, 10 y 75, dieron todas las respuestas correctas, por lo que esas pruebas pasarían. Sin embargo, un joven de 18 años es rechazado injustamente. Por eso las dos técnicas van juntas:

Utilice la partición para encontrar los grupos y luego los límites para probar dónde se encuentran los grupos. En nuestro código, una prueba separada para 17, 18, 60 y 61 pasó la función correcta y detectaría ese error. Nuestra guía de análisis de valores límite cubre esto en su totalidad.

Ventajas y limitaciones

El mayor riesgo es una suposición incorrecta. Si el código tiene una regla oculta para un valor específico, es posible que la prueba elegida simplemente no lo alcance. Las pruebas exploratorias y la cobertura del código lo ayudan a encontrar lo que omitieron las particiones.

Errores comunes

• Olvidar particiones no válidas. Probar solo rutas felices deja el manejo de errores sin marcar.
• Prueba de varios valores de una partición. Esto agrega costos sin nueva información.
• Combinando varios valores no válidos en una prueba. Un error puede ocultar otro.
• Saltar límites. Las pruebas de partición por sí solas a menudo pasan por alto errores uno por uno.
• Adivinar las reglas. Si un requisito no está claro, pregunte. ¿60 debería incluir a personas de 60 años y medio?

Conclusión

La partición de equivalencia reemplaza “¿cuántas pruebas debo escribir?” con una pregunta mucho mejor: “¿qué comportamientos existen y he cubierto cada uno de ellos?” Para probarlo, tome un formulario que esté probando hoy y enumere sus particiones en papel, incluidas las no válidas. Agregue límites a continuación. A menudo terminarás con menos pruebas que encuentren más errores.

Preguntas frecuentes

sigue aprendiendo