Cómo escribir pruebas parametrizadas con Swift Testing

Libranner Santos

23 octubre, 20244min de lectura

En el pasado, cuando necesitábamos reutilizar una misma prueba unitaria con diferentes valores, estábamos obligados a crear funciones adicionales o incluso duplicar código. Sin embargo, Swift Testing resuelve este problema al permitirnos crear pruebas parametrizadas.

Para los ejemplos, escribiremos una prueba unitaria que valide que la cantidad de ítems creados corresponde al valor asignado. Por ejemplo, si numberOfItems es igual a 5, la variable items debe contener 5 elementos. Hemos agregado un error a propósito, restando uno, para observar cómo se visualizan las pruebas fallidas:

struct Model {
  var items = [String]()

  init(numberOfItems: Int) {
    self.items = .init(repeating: "", count: numberOfItems - 1)
  }
}

A continuación, veremos un ejemplo. Así se escribía una prueba unitaria clásica con XCTest:

func testHasMultipleItems() {
  let arguments = [18, 2, 10]
  for numberOfItems in arguments {
    let model = Model(numberOfItems: numberOfItems)
    XCTAssertEqual(model.items.count, numberOfItems)
  }
}

En este sencillo ejemplo, pasamos numberOfItems al constructor de Model y verificamos que model.items sea igual al número de ítems especificado.

Con Swift Testing, la misma prueba parametrizada se vería de la siguiente forma:

@Test(
  "Multiple Items are properly stored",
  arguments: [18, 2, 10]
) 
func hasMultipleItems(numberOfItems: Int) {
  let model = Model(numberOfItems: numberOfItems)
  #expect(model.items == numberOfItems)
}

Usando la macro @Test con argumentos, la prueba se ejecuta tres veces, cada vez con un valor diferente.

Características de las pruebas parametrizadas en Swift Testing

• Resultados individualizados: A diferencia de cuando usamos XCTest, puedes ver los resultados de cada prueba por separado.
• Ejecución selectiva: Es posible ejecutar la prueba para un solo argumento haciendo clic en el botón de ejecución junto a dicho parámetro.
• Ejecución paralela: Las pruebas unitarias generadas a partir de los argumentos pueden ejecutarse en paralelo.

Además, puedes pasar múltiples conjuntos de argumentos. Por ejemplo: @Test(arguments: [18, 2], ["Apple", "Pear"]). Todas las combinaciones posibles entre estos arreglos serán probadas.

Limitando combinaciones de pruebas

El límite máximo de argumentos es de dos colecciones de datos. Si deseas limitar las combinaciones, puedes usar zip(_:_:). Por ejemplo: @Test(arguments: zip([18, 2, 10], ["Apple", "Pear, "Banana"])), lo que ejecutaría las siguientes combinaciones:

• 18, Apple
• 2, Pear

Descripciones personalizadas para pruebas parametrizadas

En algunos casos, es útil proporcionar descripciones más personalizadas para que los reportes de pruebas sean más legibles. Por ejemplo:

@Test(
  arguments: [
    Model("model 1", items: [...]),
    Model("model 1", items: [...]),
  ]
)
func processMultipleItems(model: Model) {
  model.process()
  #expect(model.items.isEmpty)
}

En este caso, el Test Navigator mostrará algo similar a:

Para mejorar la legibilidad, podemos implementar una extensión para personalizar la descripción de las pruebas:

extension Model: CustomTestStringConvertible {
  var testDescription: String {
    "\(name) with \(items.count) items"
  }
}

Aquí utilizamos CustomTestStringConvertible para proporcionar una cadena de texto más representativa de nuestro caso de prueba. Ahora, la descripción muestra el nombre del modelo y la cantidad de ítems. Este comportamiento solo estará disponible durante las pruebas, por lo que no afectará el código en producción.

Ejecución secuencial de pruebas parametrizadas

Por defecto, Swift Testing ejecuta las pruebas en paralelo y de manera aleatoria. Sin embargo, si prefieres que las pruebas se ejecuten una tras otra (sin paralelización), debes indicarlo de la siguiente manera:

@Test(
  .serialized,
  arguments: [
    Model("model 1", items: [...]),
    Model("model 1", items: [...]),
  ]
)

De esta forma, todas las pruebas en la suite se ejecutarán de manera secuencial.

Conclusión

Gracias a Swift Testing, las pruebas parametrizadas nos permiten no solo ahorrar código, sino también organizar mejor nuestras pruebas y obtener reportes más claros y estructurados. Al aprovechar esta funcionalidad, es posible optimizar nuestras suites de pruebas y mejorar la calidad del código.