Las pruebas son una parte fundamental del desarrollo de software, ya que aseguran que el código funcione como se espera y ayuda a prevenir errores en el futuro. En este módulo, aprenderás sobre la importancia de las pruebas, los diferentes tipos de pruebas y cómo implementarlas en Ruby.

¿Por qué son importantes las pruebas?

  1. Calidad del Código: Las pruebas ayudan a mantener un alto estándar de calidad en el código, asegurando que cada parte funcione correctamente.
  2. Prevención de Errores: Detectan errores y problemas antes de que lleguen a producción.
  3. Facilitan el Refactoring: Permiten realizar cambios en el código con confianza, sabiendo que las pruebas verificarán que todo sigue funcionando.
  4. Documentación: Las pruebas pueden servir como documentación adicional, mostrando cómo se espera que funcione el código.

Tipos de Pruebas

  1. Pruebas Unitarias: Verifican el funcionamiento de unidades individuales de código, como métodos o clases.
  2. Pruebas de Integración: Aseguran que diferentes partes del sistema funcionen juntas correctamente.
  3. Pruebas Funcionales: Verifican que el sistema cumpla con los requisitos funcionales.
  4. Pruebas de Aceptación: Validan que el sistema cumple con los criterios de aceptación definidos por el cliente o usuario final.

Herramientas de Pruebas en Ruby

Ruby ofrece varias herramientas y bibliotecas para realizar pruebas. Las más comunes son:

  1. Minitest: Una biblioteca de pruebas que viene incluida con Ruby. Es simple y ligera.
  2. RSpec: Una biblioteca de pruebas más avanzada y popular, conocida por su legibilidad y enfoque en el desarrollo guiado por comportamiento (BDD).

Escribiendo tu Primera Prueba con Minitest

Configuración del Entorno

Primero, asegúrate de tener Ruby instalado en tu sistema. Luego, crea un nuevo archivo para tu prueba:

mkdir my_test_project
cd my_test_project

Instalación de Minitest

Minitest viene incluido con Ruby, pero si deseas instalarlo manualmente, puedes hacerlo con:

gem install minitest

Creando una Prueba Simple

  1. Crea un archivo calculator.rb con el siguiente contenido:
class Calculator
  def add(a, b)
    a + b
  end
end
  1. Crea un archivo test_calculator.rb para las pruebas:
require 'minitest/autorun'
require_relative 'calculator'

class TestCalculator < Minitest::Test
  def setup
    @calculator = Calculator.new
  end

  def test_add
    assert_equal 4, @calculator.add(2, 2)
  end
end

Explicación del Código

  • require 'minitest/autorun': Incluye Minitest en tu archivo de prueba.
  • require_relative 'calculator': Incluye el archivo calculator.rb que contiene la clase Calculator.
  • class TestCalculator < Minitest::Test: Define una clase de prueba que hereda de Minitest::Test.
  • def setup: Método que se ejecuta antes de cada prueba, inicializando una instancia de Calculator.
  • def test_add: Define una prueba que verifica que el método add de Calculator funciona correctamente.
  • assert_equal 4, @calculator.add(2, 2): Verifica que el resultado de @calculator.add(2, 2) sea igual a 4.

Ejecutando la Prueba

Para ejecutar la prueba, simplemente corre el archivo test_calculator.rb:

ruby test_calculator.rb

Deberías ver una salida similar a:

Run options: --seed 12345

# Running:

.

Finished in 0.001234s, 1.0000 runs/s, 1.0000 assertions/s.

1 runs, 1 assertions, 0 failures, 0 errors, 0 skips

Ejercicio Práctico

Ejercicio

  1. Crea una clase StringManipulator con un método reverse_string que invierta una cadena de texto.
  2. Escribe una prueba para verificar que el método reverse_string funciona correctamente.

Solución

  1. Crea el archivo string_manipulator.rb:
class StringManipulator
  def reverse_string(str)
    str.reverse
  end
end
  1. Crea el archivo test_string_manipulator.rb:
require 'minitest/autorun'
require_relative 'string_manipulator'

class TestStringManipulator < Minitest::Test
  def setup
    @string_manipulator = StringManipulator.new
  end

  def test_reverse_string
    assert_equal 'olleh', @string_manipulator.reverse_string('hello')
  end
end
  1. Ejecuta la prueba:
ruby test_string_manipulator.rb

Conclusión

En esta lección, has aprendido la importancia de las pruebas, los diferentes tipos de pruebas y cómo escribir pruebas unitarias básicas utilizando Minitest en Ruby. En la siguiente lección, profundizaremos en las pruebas unitarias con Minitest y exploraremos más características avanzadas.

© Copyright 2024. Todos los derechos reservados