El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Pruebas y Depuración

Siguiente ►
►

En esta sección, aprenderás cómo realizar pruebas y depuración en tu proyecto final de Ruby. Este es un paso crucial para asegurar que tu aplicación funcione correctamente y esté libre de errores. Vamos a cubrir los siguientes temas:

  1. Importancia de las Pruebas y la Depuración
  2. Tipos de Pruebas
  3. Herramientas de Pruebas en Ruby
  4. Escribiendo Pruebas Unitarias
  5. Depuración en Ruby
  6. Ejercicios Prácticos

  1. Importancia de las Pruebas y la Depuración

Las pruebas y la depuración son esenciales en el desarrollo de software por varias razones:

  • Calidad del Software: Aseguran que el software funcione como se espera.
  • Mantenimiento: Facilitan la identificación y corrección de errores.
  • Confianza: Proporcionan confianza en el código, especialmente cuando se realizan cambios o se añaden nuevas funcionalidades.

  1. Tipos de Pruebas

Existen varios tipos de pruebas que puedes realizar en tu aplicación:

  • Pruebas Unitarias: Verifican el funcionamiento de unidades individuales de código, como métodos o clases.
  • Pruebas de Integración: Aseguran que diferentes módulos o servicios de la aplicación funcionen juntos correctamente.
  • Pruebas Funcionales: Verifican que la aplicación funcione según lo esperado desde la perspectiva del usuario.
  • Pruebas de Sistema: Evalúan el sistema completo en un entorno que simula el entorno de producción.

  1. Herramientas de Pruebas en Ruby

Ruby ofrece varias herramientas para realizar pruebas:

  • Minitest: Una biblioteca de pruebas que viene con Ruby por defecto.
  • RSpec: Una herramienta de pruebas más avanzada y popular en la comunidad Ruby.
  • Capybara: Utilizada para pruebas de aceptación y simulación de interacciones del usuario.

  1. Escribiendo Pruebas Unitarias

Vamos a escribir algunas pruebas unitarias utilizando Minitest. Supongamos que tenemos una clase Calculator con un método add:

# calculator.rb
class Calculator
  def add(a, b)
    a + b
  end
end

Escribiendo Pruebas con Minitest

Primero, asegúrate de tener Minitest instalado. Puedes instalarlo con:

gem install minitest

Luego, crea un archivo de prueba:

# test_calculator.rb
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)
    assert_equal 0, @calculator.add(-1, 1)
  end
end

Para ejecutar las pruebas, simplemente corre el archivo de prueba:

ruby test_calculator.rb

Explicación del Código

  • require 'minitest/autorun': Carga Minitest y ejecuta las pruebas automáticamente.
  • require_relative 'calculator': Incluye el archivo que contiene la clase Calculator.
  • setup: Método que se ejecuta antes de cada prueba para inicializar el objeto @calculator.
  • test_add: Método de prueba que verifica si el método add funciona correctamente.

  1. Depuración en Ruby

La depuración es el proceso de identificar y corregir errores en el código. Ruby proporciona varias herramientas para la depuración:

Uso de puts y p

La forma más sencilla de depurar es utilizando puts y p para imprimir valores en la consola:

def add(a, b)
  puts "a: #{a}, b: #{b}"
  a + b
end

Uso de byebug

byebug es una herramienta de depuración más avanzada. Puedes instalarla con:

gem install byebug

Luego, puedes usarla en tu código:

require 'byebug'

def add(a, b)
  byebug
  a + b
end

Cuando ejecutes el código, se detendrá en la línea byebug, permitiéndote inspeccionar variables y ejecutar comandos de depuración.

  1. Ejercicios Prácticos

Ejercicio 1: Escribir Pruebas Unitarias

Escribe pruebas unitarias para la siguiente clase StringManipulator:

# string_manipulator.rb
class StringManipulator
  def reverse_string(str)
    str.reverse
  end

  def upcase_string(str)
    str.upcase
  end
end

Solución:

# test_string_manipulator.rb
require 'minitest/autorun'
require_relative 'string_manipulator'

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

  def test_reverse_string
    assert_equal 'olleh', @manipulator.reverse_string('hello')
    assert_equal '', @manipulator.reverse_string('')
  end

  def test_upcase_string
    assert_equal 'HELLO', @manipulator.upcase_string('hello')
    assert_equal 'WORLD', @manipulator.upcase_string('world')
  end
end

Ejercicio 2: Depuración con byebug

Añade una línea de byebug en el método reverse_string y depura el siguiente código:

# debug_example.rb
require 'byebug'
require_relative 'string_manipulator'

manipulator = StringManipulator.new
puts manipulator.reverse_string('hello')

Solución:

# string_manipulator.rb
class StringManipulator
  def reverse_string(str)
    byebug
    str.reverse
  end

  def upcase_string(str)
    str.upcase
  end
end

Ejecuta debug_example.rb y utiliza los comandos de byebug para inspeccionar el valor de str.

Conclusión

En esta sección, hemos aprendido la importancia de las pruebas y la depuración, los diferentes tipos de pruebas, y cómo escribir pruebas unitarias y depurar código en Ruby. Estas habilidades son esenciales para asegurar la calidad y el correcto funcionamiento de tu aplicación. Ahora estás listo para aplicar estas técnicas en tu proyecto final y asegurar que tu código sea robusto y libre de errores.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados