Repository: iluwatar/java-design-patterns
Issue: Translate arrange-act-assert to spanish (Task of issue #2277)
Labels: type: feature
epic: translation

Translation of [arrange-act-assert/README.md](https://github.com/iluwatar/java-design-patterns/blob/master/arrange-act-assert/README.md) to [java-design-patterns/localization/es/arrange-act-assert/](https://github.com/iluwatar/java-design-patterns/tree/master/localization/es/) folder
Task of issue #2277 

Issue comments:
Subtask of https://github.com/iluwatar/java-design-patterns/issues/2277

Pull request review comments:

Patch that resolved the issue:
diff --git a/localization/es/arrange-act-assert/README.md b/localization/es/arrange-act-assert/README.md
new file mode 100644
index 000000000000..d5411e63b7ad
--- /dev/null
+++ b/localization/es/arrange-act-assert/README.md
@@ -0,0 +1,140 @@
+---
+title: Arrange/Act/Assert
+category: Idiom
+language: es
+tag:
+ - Testing
+---
+
+## También conocido como
+
+Dado/Cuando/Entonces
+
+## Intención
+
+Arrange/Act/Assert (AAA) es un patrón para organizar UnitTests.
+Divide las UnitTests en tres pasos claros y diferenciados:
+
+1. Arrange(Organizar): Realiza la configuración y la inicialización necesarias para el test.
+2. Act(Actuar): Toma las medidas necesarias para el test.
+3. Assert(Afirmar): Verifica los resultados del test.
+
+## Explicacació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.
+
+```java
+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.
+
+```java
+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/Asert cuando
+
+* Necesites estructurar tus UnitTests para que sean más fáciles de leer, mantener y mejorar.
+
+## Créditos
+
+* [Arrange, Act, Assert: ¿Qué son las pruebas AAA?](https://blog.ncrunch.net/post/arrange-act-assert-aaa-testing.aspx)
+* [Bill Wake: 3A – Arrange, Act, Assert](https://xp123.com/articles/3a-arrange-act-assert/)
+* [Martin Fowler: DadoCuandoEntonces](https://martinfowler.com/bliki/GivenWhenThen.html)
+* [Patrones de prueba xUnit: Refactorizando Código de prueba](https://www.amazon.com/gp/product/0131495054/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0131495054&linkId=99701e8f4af2f63d0bcf50)
+* [Principios, prácticas y patrones UnitTesting](https://www.amazon.com/gp/product/1617296279/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617296279&linkId=74c75cfae3a5a)accae3a5a)
+* [Desarrollo basado en pruebas: Ejemplo](https://www.amazon.com/gp/product/0321146530/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321146530&linkId=5c63a93d8c1175b47caef50875)
diff --git a/localization/es/async-method-invocation/README.md b/localization/es/async-method-invocation/README.md
new file mode 100644
index 000000000000..756f686767f6
--- /dev/null
+++ b/localization/es/async-method-invocation/README.md
@@ -0,0 +1,168 @@
+---
+title: Async Method Invocation
+category: Concurrency
+language: es
+tag:
+ - Reactive
+---
+
+## Propósito
+
+Asynchronous method invocation (invocación de método asincrónico) es un patrón con el que el hilo o subproceso de llamada
+no se bloquea mientras espera resultados. El patrón proporciona pocesamiento en paralelo de múltiples tareas independientes y recupera los resultados a través de
+devoluciones de llamada (callbacks) o esperando hasta que termine el procedimiento.
+
+## Explicación
+
+Ejemplo cotidiano
+
+> Lanzar cohetes espaciales es un negocio apasionante. El comandante de la misión da la orden de lanzamiento y
+> después de un tiempo indeterminado, el cohete se lanza con éxito o falla miserablemente.
+
+En otras palabras
+
+> La invocación del método asíncrono inicia el procedimiento y vuelve inmediatamente antes de que la tarea termine
+> Los resultados del procedimiento se devuelven a la llamada  posteriormente (callback).
+
+Según Wikipedia
+
+> En la programación multiproceso, la invocación de método asíncrono (AMI), también conocida como
+> llamadas de método asíncrono o el patrón asíncrono es un patrón de diseño en el que el lugar de la llamada
+> no se bloquea mientras espera que termine el código llamado. En cambio, el hilo de llamada es
+> notificado cuando llega la respuesta. Sondear para obtener una respuesta es una opción no deseada.
+
+**Ejemplo programático**
+
+En este ejemplo, estamos lanzando cohetes espaciales y desplegando vehículos lunares.
+
+La aplicación demuestra lo que hace el patrón de invocación del método asíncrono. Las partes clave del patrón son
+`AsyncResult` que es un contenedor intermedio para un valor evaluado de forma asíncrona,
+`AsyncCallback` que se puede proporcionar para que se ejecute al finalizar la tarea y `AsyncExecutor` que
+gestiona la ejecución de las tareas asíncronas.
+
+```java
+public interface AsyncResult<T> {
+  boolean isCompleted();
+  T getValue() throws ExecutionException;
+  void await() throws InterruptedException;
+}
+```
+
+```java
+public interface AsyncCallback<T> {
+  void onComplete(T value, Optional<Exception> ex);
+}
+```
+
+```java
+public interface AsyncExecutor {
+  <T> AsyncResult<T> startProcess(Callable<T> task);
+  <T> AsyncResult<T> startProcess(Callable<T> task, AsyncCallback<T> callback);
+  <T> T endProcess(AsyncResult<T> asyncResult) throws ExecutionException, InterruptedException;
+}
+```
+
+`ThreadAsyncExecutor` es una implementación de `AsyncExecutor`. Se destacan algunas de sus partes clave a continuación.
+
+```java
+public class ThreadAsyncExecutor implements AsyncExecutor {
+
+  @Override
+  public <T> AsyncResult<T> startProcess(Callable<T> task) {
+    return startProcess(task, null);
+  }
+
+  @Override
+  public <T> AsyncResult<T> startProcess(Callable<T> task, AsyncCallback<T> callback) {
+    var result = new CompletableResult<>(callback);
+    new Thread(
+            () -> {
+              try {
+                result.setValue(task.call());
+              } catch (Exception ex) {
+                result.setException(ex);
+              }
+            },
+            "executor-" + idx.incrementAndGet())
+        .start();
+    return result;
+  }
+
+  @Override
+  public <T> T endProcess(AsyncResult<T> asyncResult)
+      throws ExecutionException, InterruptedException {
+    if (!asyncResult.isCompleted()) {
+      asyncResult.await();
+    }
+    return asyncResult.getValue();
+  }
+}
+```
+
+Ahora está todo preparado para lanzar algunos cohetes y así poder ver cómo funciona todo.
+
+```java
+public static void main(String[] args) throws Exception {
+  // construye un nuevo objeto executor que ejecutará tareas asíncronas
+  var executor = new ThreadAsyncExecutor();
+
+  // inicia algunas tareas asíncronas con diferentes tiempos de procesamiento, las dos últimas con controladores de devolución de llamada
+  final var asyncResult1 = executor.startProcess(lazyval(10, 500));
+  final var asyncResult2 = executor.startProcess(lazyval("test", 300));
+  final var asyncResult3 = executor.startProcess(lazyval(50L, 700));
+  final var asyncResult4 = executor.startProcess(lazyval(20, 400), callback("Desplegando el rover lunar"));
+  final var asyncResult5 =
+      executor.startProcess(lazyval("devolución de llamada callback", 600), callback("Desplegando el rover lunar"));
+
+  // emula el procesamiento en el hilo o subproceso actual mientras las tareas asíncronas se ejecutan en sus propios hilos o subprocesos
+  Subproceso.dormir(350); // Oye, estamos trabajando duro aquí
+  log("El comandante de la misión está bebiendo café");
+
+  // espera a que se completen las tareas
+  final var result1 = executor.endProcess(asyncResult1);
+  final var result2 = executor.endProcess(asyncResult2);
+  final var result3 = executor.endProcess(asyncResult3);
+  asyncResult4.await();
+  asyncResult5.await();
+
+  // registra los resultados de las tareas, las devoluciones de las llamadas se registran inmediatamente cuando se completan
+  log("Cohete espacial <" + resultado1 + "> ha completado su lanzamiento");
+  log("Cohete espacial <" + resultado2 + "> ha completado su lanzamiento");
+  log("Cohete espacial <" + result3 + "> ha completado su lanzamiento");
+}
+```
+
+Aquí está la salida de la consola del programa.
+
+```java
+21:47:08.227 [executor-2] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <prueba> lanzado con éxito
+21:47:08.269 [main] INFO com.iluwatar.async.method.invocation.App - El comandante de la misión está bebiendo café
+21:47:08.318 [executor-4] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <20> lanzado con éxito
+21:47:08.335 [executor-4] INFO com.iluwatar.async.method.invocation.App Desplegando el rover lunar <20>
+21:47:08.414 [executor-1] INFO com.iluwatar.async.method.invocation.App  - Cohete espacial <10> lanzado con éxito
+21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <devolución de llamada callback> lanzado con éxito
+21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Implementando el vehículo lunar <devolución de llamada callback>
+21:47:08.616 [executor-3] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <50> lanzado con éxito
+21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <10> completado
+21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento de cohete espacial <prueba> completado
+21:47:08.618 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <50> completado
+```
+
+# Diagrama de clase
+
+![texto alternativo](./etc/async-method-invocation.png "Invocación de método asíncrono")
+
+## Aplicabilidad
+
+Utiliza el patrón de invocación del método asíncrono cuando
+
+* Tienes múltiples tareas independientes que pueden ejecutarse en paralelo
+* Necesitas mejorar el desempeño de un grupo de tareas secuenciales
+* Tienes una cantidad limitada de capacidad de procesamiento o tareas de ejecución prolongada y la llamada no debe esperar a que las tareas estén listas
+
+## Ejemplos cotidianos
+
+* [FutureTask](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/FutureTask.html)
+* [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html)
+* [ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
+* [Patrón asíncrono basado en tareas](https://msdn.microsoft.com/en-us/library/hh873175.aspx)
\ No newline at end of file


Test patch: