Arrange/Act/Assert

Alrededor de 2 min

Propósito

Arrange/Act/Assert (AAA) es un patrón para organizar UnitTests.
Divide las UnitTests en tres pasos claros y diferenciados:

Arrange(Organizar): Realiza la configuración y la inicialización necesarias para el test.
Act(Actuar): Toma las medidas necesarias para el test.
Assert(Afirmar): Verifica los resultados del test.

Este patrón tiene varios beneficios significativos. Crea una clara separación entre la configuración, operaciones y resultados de un test. Esta estructura hace que el código sea más fácil de leer y comprender. Si
colocas los pasos en orden y formateas su código para separarlos, puedes escanear un test y
comprender rápidamente lo que hace.

También impone un cierto grado de disciplina cuando escribes tus UnitTests. Tienes que visualizar
claramente los tres pasos que tu test realizará. Esto hace que los tests sean más intuitivos de escribir a la vez que tienes presente un esquema.

Ejemplo cotidiano

Necesitamos escribir un conjunto de UnitTests completo y claro para una clase.

En otras palabras

Arrange/Act/Assert es un patrón de testeo que organiza las pruebas en tres pasos claros para facilitar su
mantenimiento.

WikiWikiWeb dice

Arrange/Act/Assert es un patrón para organizar y dar formato al código en los métodos UnitTest.

Código de ejemplo

Veamos primero nuestra clase Cash para que sea testeada.

public class Cash {

  private int amount;

  Cash(int amount) {
    this.amount = amount;
  }

  void plus(int addend) {
    amount += addend;
  }

  boolean minus(int subtrahend) {
    if (amount >= subtrahend) {
      amount -= subtrahend;
      return true;
    } else {
      return false;
    }
  }

  int count() {
    return amount;
  }
}

Luego escribimos nuestras UnitTests en función del patrón Arrange/Act/Assert. Note claramente la separación de los pasos para cada UnitTest.

class CashAAATest {

  @Test
  void testPlus() {
    //Arrange
    var cash = new Cash(3);
    //Act
    cash.plus(4);
    //Assert
    assertEquals(7, cash.count());
  }

  @Test
  void testMinus() {
    //Arrange
    var cash = new Cash(8);
    //Act
    var result = cash.minus(5);
    //Assert
    assertTrue(result);
    assertEquals(3, cash.count());
  }

  @Test
  void testInsufficientMinus() {
    //Arrange
    var cash = new Cash(1);
    //Act
    var result = cash.minus(6);
    //Assert
    assertFalse(result);
    assertEquals(1, cash.count());
  }

  @Test
  void testUpdate() {
    //Arrange
    var cash = new Cash(5);
    //Act
    cash.plus(6);
    var result = cash.minus(3);
    //Assert
    assertTrue(result);
    assertEquals(8, cash.count());
  }
}

Aplicabilidad

Utilice el patrón Arrange/Act/Assert cuando

Necesitas estructurar tus UnitTests para que sean más fáciles de leer, mantener y mejorar.

Arrange/Act/Assert

También conocido como

Propósito

Explicación

Aplicabilidad

Créditos