Como desarrolladores deberíamos utilizar las pruebas unitarias para ahorrar tiempo en tareas importantes, pocos lo hacemos ya que nunca tenemos “tiempo”, mientras menos pruebas realicemos más probabilidades tenemos de que el código sea menos estable y falle.

Acotando que en el mundo del desarrollo de software existen muchos tipos de pruebas. Señalo cuales son algunas de ellas:

  • Pruebas unitarias: Accede verificar de forma individual una funcionalidad de nuestra app, representada normalmente por un método del código fuente.
  • Pruebas funcionales: Permiten verificar que la funcionalidad que desempeña nuestra app se ajusta a los requisitos de la misma.
  • Pruebas integradas: Deja verificar la integración de diferentes elementos software, una vez que se han verificado unitariamente.
  • Pruebas de rendimiento: Concede verificar el rendimiento ofrecido por las diferentes funcionalidades que contempla nuestra app.

Para entrar en tema primeramente hare saber que son pruebas unitarias para esas personas que se están introduciendo en este campo.

Una prueba unitaria en precisas palabras es lo que verifica el desarrollo de la funcionalidad del código de manera rápida y simple.

Como todo, esto posee ciertas características importantes que ha de saber:

  • Prueba pequeñas cantidades de código.
  • No debe depender ni afectar a otras pruebas unitarias (Independiente).
  • Es repetible y predecible, no debe chocar con el orden y las veces que se repita la prueba el resultado tiene que ser el mismo todo el tiempo.
  • Automatizable, la prueba no debería requerir intervención manual.

El aplicar pruebas unitarias posee sus ventajas.

  • Principalmente es menos errores y más fáciles de localizar.
  • Estas reducen la cantidad de errores y tiempo en localizarlos.
  • Promueve el cambio.
  • Las pruebas unitarias permiten reordenar el código ya que acepta hacer pruebas sobre los cambios.

Adoptar el uso de pruebas unitarias como una disciplina no se debe considerar como una desventaja, todo lo contrario, debemos entender que esta actividad nos servirá para ahorrar tiempo en el futuro la ocurrencia de errores. El uso de estas nos permitirá mejorar progresivamente la calidad del código que desarrollamos en la medida que vayamos aumentado su aplicación en nuestros proyectos.

¿Qué tipos de pruebas unitarias existen en Xcode?

En Xcode existen principalmente dos tipos de pruebas unitarias:

  • Pruebas unitarias lógicas: Verifican el correcto funcionamiento de un fragmento de código de forma independiente (sin encontrarse dentro de nuestra app). Sólo pueden ejecutarse en el Simulador de Xcode.
  • Pruebas unitarias de aplicación: Verifican el correcto funcionamiento de fragmentos de código dentro del contexto de nuestra app. Esto nos permite verificar, entre otros, que las conexiones IBOutlets y IBActions de nuestra app sin correctas, e incluso que los controles y controladores de nuestra app funcionan correctamente con respecto a nuestro modelo. Estos test nos van a permitir también verificar funcionalidades específicas de un dispositivo, como el uso de la geolocalización, acelerómetro, etc.

Buenas prácticas para la escritura de casos de prueba.

Siguiendo las indicaciones en la guía Xcode Unit Testing Guide, nos sugiere tener en cuenta lo siguiente:

  • Define los requisitos de tu API: debemos definir para cada uno de los métodos de nuestro proyecto, los posibles rangos de valores de entrada, excepciones que deben producirse en qué casos, y los valores de retorno para cada una de las casuísticas posibles.
  • Escribe pruebas unitarias mientras escribes tu código: Con esto quiere decir que no dejemos para el final la escritura de pruebas, sino que sea un proceso iterativo a lo largo del desarrollo de nuestra app.
  • Comprueba los valores mínimos y máximos: Es decir que si nuestro método esperar recibir un valor entre 0 y 100, hagamos casos de prueba para los valores 0, 50 y 100 por ejemplo.
  • Utiliza pruebas negativas: Con estas pruebas verificamos que nuestro código se comporta correctamente antes parámetros incorrectos, como por ejemplo un valor 200 para el método anterior.
  • Da cobertura a los bugs con casos de prueba: cuando corrijamos nuestro código para solventar un bug detectado, escribamos un caso de prueba para verificar automáticamente la corrección de dicho bug en el futuro.

Ejemplo básico de prueba unitaria en Xcode:

La clase Test es donde tendremos nuestras funciones a probar:

import Foundation

class Test {
    
    //This function adds two numbers.
    func sum(a:Int, b:Int) -> Int {
        return a+b
    }
    
    //This function subtracts two numbers.
    func sub(a:Int, b:Int) -> Int {
        return a-b
    }
    
    //This function divides two numbers.
    func div(a:Int, b:Int) -> Int {
        return a/b
    }
    
    //This function multiplies two numbers.
    func mul(a:Int, b:Int) -> Int {
        return a*b
    }
}

Despúes en nuestro archivo de prueba unitaria debemos crear un método que siempre lleve la palabra ‘test’ de primero, por ejemplo:

  •     testExample()
  •     testValidation()
  •     testGenerate()
    func testExample() {
        let test = Test()
        
        //This a success case.
        XCTAssertEqual(test.sum(a: 2, b: 2), 4, "Function works perfectly.")
        
        //This a fail case
        XCTAssertNotEqual(test.sum(a: 2, b: 2), 5)
    }

Como ultimo paso presionamos el botón play y Xcode se encarga de realizar las pruebas.