Pasar al contenido principal

🔥 ¡Hoy! Clase gratis de Diseño web con Bootstrap 😍 Reserva tu lugar. Comienza en:

Alexys Lozada
José Luján
Manuel Rodriguez
José Luján
Luis Avilés
Álvaro Felipe
José Luján
Beto Quiroga
Jonathan MirCha
Jonathan MirCha
Álvaro Felipe
Alexys Lozada, Álvaro Felipe, Jonathan MirCha
Beto Quiroga
Alexys Lozada
Alexys Lozada
José Luján
Álvaro Felipe
Álvaro Felipe
Jonathan MirCha
Jonathan MirCha
Alexys Lozada, José Luján
Alexys Lozada, José Luján
Alexys Lozada, José Luján
Camilo Adobe
Álvaro Felipe
José Luján
Jonathan MirCha
Álvaro Felipe
Álvaro Felipe
Beto Quiroga, Alexys Lozada
Álvaro Felipe
Juan Villalvazo
Luis Avilés
Jonathan MirCha
Jonathan MirCha
Jonathan MirCha

¿Qué es el TDD?

Es una metodología de desarrollo cuyo objetivo es crear primero las pruebas y luego escribir el software. Es decir, desarrollo guiado por pruebas.

Qué es TDD?

Desarrollo guiado por pruebas

Es una metodología de desarrollo cuyo objetivo es crear primero las pruebas y luego escribir el software. Sus siglas en Inglés son: Test Driven Development y en español significa: Desarrollo guiado por pruebas.

No es nada nuevo este concepto, incluso muchos de ustedes lectores tendrán menos edad que esta metodología. Fue a finales de los años 80 donde se comenzó a utilizar esta metodología de desarrollo.

Para el uso del TDD se deben combinar 2 metodologías: Test-first development (escribir las pruebas primero) y Refactoring (refactorización de código). Para esto, se usa un ciclo de desarrollo que consta de 3 partes principales:

  • La prueba debe fallar. (Red: Muchas herramientas muestran los fallos de las pruebas en rojo)
  • La prueba debe pasar. (Green: Al igual que lo anterior, las herramientas muestran las pruebas que pasan en verde)
  • Se debe mejorar el código. (Refactoring)

Si por alguna razón tu no refactorizas tu código, ya no se cumple con el ciclo del TDD y simplemente sería un Test-first development. Nota personal: En tecnología nos encanta poner nombres diferentes por cualquier cambio.

Ventajas del TDD

  • Puedes mejorar el código de tu aplicación en cualquier momento sin miedo a que dañes algo, ya que las pruebas ya las tienes listas y deberán pasar siempre.
  • Los test que realizamos sobre las interfaces de nuestra app no siempre son completos, generalmente es lo que nos acordamos probar.
  • Los equipos de testing, development y analyst serán más felices.
  • La lectura del código será mucho mejor al tener ejemplos de uso (las pruebas).

Herramientas

Dependiendo del lenguaje de programación, puedes escoger entre decenas de frameworks que te permitirán hacer pruebas, algunos conocidos son:

  • Java - JUnit, REST assured, Selenium, Mockito, Spock, etc.
  • JavaScript - Jasmine, AVA, Tape, Mocha, Jest, etc.
  • PHP - PHPUnit, Codeception, Behat, PHPSpec, SimpleTest, Storyplayer, etc.
  • Python - [https://wiki.python.org/moin/PythonTestingToolsTaxonomy](clic para ver algunas herramientas)
  • Go - El paquete testing nativo de Go.

No pregunten cual framework es el mejor para tu lenguaje de programación, prueben con varios y escojan con el que mejor se sientan.

Manos a la obra

Hagamos un TDD para el factorial de un número:

  1. Creamos la prueba en el archivo factorial_test.go:
package factorial

import  "testing"

func  TestFactorial(t *testing.T) {
	result := Factorial(5)
	want := 120
	if result != want {
		t.Errorf("Se esperaba %d, se obtuvo: %d", want, result)
	}
}

Si ejecutamos la prueba fallará la primera vez ya que no existe la función Factorial(n int), pero esa no es la falla que queremos, las fallas de compilación no cuentan, así que debemos crear un código que cumpla con el resultado esperado.

  1. Creamos el código que cumpla la prueba en el archivo factorial.go:
package factorial

func  Factorial(n int) int {
	return  120
}

Ahora tenemos una función que cumple con lo solicitado. Obviamente no estamos calculando un factorial de manera correcta, pero aún no lo sabemos, ya que si ejecutamos la prueba, esta pasará sin problemas. Así que vamos a agregar más pruebas para comprobar que el código funciona:

  1. Agregamos más pruebas a nuestro archivo factorial_test.go:
package factorial

import  "testing"

func  TestFactorial(t *testing.T) {
	table := []struct{
		Fact int
		Want int
	}{
		{1, 1},
		{2, 2},
		{3, 6},
		{4, 24},
		{5, 120},
	}

	for  _, v := range table {
		result := Factorial(v.Fact)
		if result != v.Want {
			t.Errorf("Se esperaba %d, se obtuvo: %d", v.Want, result)
		}
	}
}
  1. Ahora escribiremos el código para que realmente funcione el factorial. Archivo factorial.go:
package factorial

func  Factorial(n int) int {
	r := 1
	for  i := n; i > 1; i-- {
		r *= i
	}

	return r
}

Perfecto, ahora nuestras pruebas pasan totalmente. Pero, aún nos falta algo... la refactorización del código. Pues ahora necesitamos utilizar recursividad para resolver el problema ya que con ciclos nuestro proceso se convierte en un infierno (es totalmente hipotético, utilizo el ejemplo a manera de metáfora). Entonces manos a la obra, cambiaremos nuestro código sin temor a dañar algo ya que nuestras pruebas revisarán que nuestro código siga haciendo lo que necesitamos que haga:

  1. Refactorización del archivo factorial.go:
package factorial
  
func  Factorial(n int) int {
	if n == 0 || n == 1 {
		return  1
	}

	return  Factorial(n-1) * n
}

Voila! las pruebas pasan sin preocupaciones y pudimos refactorizar nuestro código.

No esperes más, comienza ya mismo a hacer tus Test-first development y luego refactoriza tu código para terminar realizando un buen TDD.

Nos vemos en el EDcamp Lima 2018, no olvides comprar tus entradas en: https://ed.team/edcamp

Suscríbete al blog de EDteam

Ingresa tu correo electrónico para recibir nuestro boletín semanal