Property-based testing vs Unit testing. ¿De verdad tengo que elegir?

Maricela

  • Soy desarrolladora en Nearsoft
  • Organizadora dentro de PythonDay México y PyMX y PyCon Charlas
  • Organizadora dentro de Rust Latam Conf y RustMX
  • Directora dentro de Women Who Code CDMX y líder dentro de Women Who Code Python

Unit testing

Código que comprueba la funcionalidad de una unidad de código productivo

# calc.py 

def add(first_number, second_number):
    return first_number + second_number
    
    
# tests.py

from .calc import add

def test_add_equals_to_8():
    assert add(5, 3) == 8

def test_add_equals_to_5():
    assert add(2, 3) == 5

Se basa en ejemplos que comprueban la funcionalidad

import unittest 
  
class TestStringMethods(unittest.TestCase): 
      
    def setUp(self): 
        pass
  
    # Retorna True si la cadena contiene 4 a. 
    def test_strings_a(self): 
        self.assertEqual( 'a'*4, 'aaaa') 
  
    # Retorna True si la cadena está en mayúsculas 
    def test_upper(self):         
        self.assertEqual('foo'.upper(), 'FOO') 
  
    # Retorna True si la primera letra de la cadena está en 
    # mayúscula de otro modo retorna False
    def test_isupper(self):         
        self.assertTrue('FOO'.isupper()) 
        self.assertFalse('Foo'.isupper())

Ventajas

  • Código de mayor calidad
  • Detección de errores de manera temprana
  • Favorece la integración continúa
  • Sirve como documentación

desVentajas

  • Solo compruebas casos concretos
  • Si quieres cubrir la mayor parte de escenarios debes escribir muchas pruebas
  • Pierdes de vista lo que realmente deseas probar.

Property-based testing

Las pruebas basadas en propiedad comprueban una especificación abstracta

from hypothesis import given
 	import hypothesis.strategies as some
	
	@given (some.lists(some.integers()))
	def test_list_size_is_invariant_across_sorting(a_list):
 	    original_length = len(a_list)
 	    a_list.sort()
 	    assert len(a_list) == original_length
 	
 	@given(some.lists(some.text()))
 	def test_sorted_result_is_ordered(a_list):
 	    a_list.sort()
 	    for i in range(len(a_list) - 1):
			assert a_list[i] <= a_list[i + 1]

En vez probar un ejemplo a la vez podemos establecer la propiedad que queremos comprobar

@given(some.integers())

Ventajas

  • Probamos muchos casos a la vez
  • Disminuimos la posiblidad de errores ya que le cedemos el control a la máquina
  • Validamos suposiciones

desVentajas

  • Es una técnica poco explorada
  • No existe un framework para esta técnica en todos los lenguajes

¿Debo elegir una técnica u otra?

NO

Ambas técnicas son complementarias y te ayudarán a mantener mayor calidad en el software que desarrollas

https://www.meetup.com/es/__PyMX__

https://pythondaymx.github.io/

¡gracias!

Made with Slides.com