Luis Mateo Hincapié Martinez
dc7495e8bd
* Typo corrections * bridge pattern translated to spanish * builder pattern translated to spanish * context-object pattern translated to spanish * converter pattern translated to spanish * dependency injection pattern translated to spanish * factory pattern translated to spanish * factory-kit pattern translated to spanish * factory-method pattern translated to spanish * monostate pattern translated to spanish * multiton pattern translated to spanish * object mother pattern translated to spanish * object pool pattern translated to spanish * property pattern translated to spanish * prototype pattern translated to spanish * registry pattern translated to spanish * step builder pattern translated to spanish * value object pattern translated to spanish * typo corrections and resources urls refactor * grammar corrections * Add image to each pattern --------- Co-authored-by: luismateoh <luismateohm@gmail.com> Co-authored-by: luis.hincapie <luis.hincapie@blankfactor.com>
title, category, language, tag
| title | category | language | tag | |
|---|---|---|---|---|
| Arrange/Act/Assert | Idiom | es |
|
También conocido como
Dado/Cuando/Entonces
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.
Explicación
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.