Compartido

Actualmente nos encontramos en un punto en el que todavía no tenemos una primera maquetación de la interfaz de usuario de flatee, pero de todas formas estamos desarrollando.

¿Cómo lo hacemos?. Bien, estamos desarrollando con la ayuda de test funcionales para comprobar que todo lo que hacemos está correcto. Además estos tests nos servirán para comprobar que no se rompe nada con futuras modificaciones, y si se rompe ver que es lo que hemos tocado más de la cuenta.

Ruby on Rails nos trae de serie la posibilidad de crear test funcionales, verificando las acciones de nuestros controladores. Cada vez que generamos un controlador, se nos crea en el mismo momento una clase en [nombre_app]/test/functional/[mi_controller]_test.rb, donde podremos definir nuestras pruebas. Esa clase hereda de ActionController::TestCase, y en ella utilizaremos implementaciones para test de request y response, y haremos peticiones HTTP (get, post, put, head y delete) pudiendo pasar parámetros, comparando los resultados de esas llamadas con assertions,etc.

Por otro lado, tenemos los fixtures, que se crean al generar las clases modelo. Los fixtures, por defecto, son unos ficheros con formato YAML donde introducimos datos de prueba a los que nos referiremos en nuestros tests. Como es de imaginar los fixtures se pueden utilizar también en test unitarios.

Una vez explicado esto, veamos como es la práctica. En nuestro caso tenemos un modelo piso con ciudad y precio; un fixture de pisos; y un pisos_controller con las acciones listado y crear.

Este podría ser nuestro fixture(nombreapp/test/fixtures/piso.yml):

    piso_madrid:
      id: 1
      ciudad: 'Madrid'
      precio: 350

Nuestras acciones de pisos_controller.rb:

    def listado
      @pisos = Piso.find(:all)
    end
    def crear
      @piso = Piso.new(params[:piso])
      respond_to do |format|
        flash[:notice] = ‘Piso creado correctamente.’
        format.html { redirect_to piso_path(@piso) }
      end
    end

Y ahora vamos a escribir el test pisos_controller_test.rb: Requerimos el controlador que vamos a testear

    require 'pisos_controller'

Definimos qué fixtures utilizaremos, en nuestro caso sólo uno:

    fixtures :pisos

Hacemos el setup con las implementaciones para testing de request y response, además decimos qué controller vamos a utilizar:

    def setup
      @controller = PisosController.new
      @request = ActionController::TestRequest.new
      @response = ActionController::TestResponse.new
    end

Y los tests:

    def test_listado
      #Peticion get al listado
      get :listado
      #Comprobamos que el @pisos del listado, que viene a ser assigns(:pisos), no sea nulo
      assert_not_nil assigns(:pisos)
      #Debe haber un piso, es el que se crea con el fixture
      assert_equal assigns(:pisos).size,1
    end
    def test_crear
      #Peticion post al crear con parámetros
      post :crear, :piso=>{:ciudad=>'Cuatrecorz',:precio=>100}
      #Comprobamos que los valores insertados sean correctos
      assert_equal assigns(:piso).ciudad,'Cuatrecorz'
      assert_equal assigns(:piso).precio,100
      #Comprobamos también la redirección
      assert_redirected_to piso_path(assigns(:piso))
    end

Cuando ejecutemos el test, podremos ver si nuestros controladores se están comportando de manera adecuada y lo que es más interesante aún… podremos ejecutarlos de manera continua a lo largo de la vida del proyecto para evitar que cambios futuros puedan introducir nuevos errores.

La experiencia de los tests esta siendo muy interesante y estamos aprendiendo como hacer nuestro software más robusto: ¡os animamos a que probéis a testar vuestro aplicaciones si es que todavía no lo hacéis!.