// Un estante con tres espacios fijos
const estanteNumerado: string[] = ["Libro", "Marco de Fotos", "Reloj"];

// Acceso instantáneo al elemento en el espacio 0 (índice base 0)
const primerElemento = estanteNumerado[0]; // "Libro"

// Acceso instantáneo al elemento en el espacio 1 (índice base 0)
const segundoElemento = estanteNumerado[1]; // "Marco de Fotos"

// Acceso instantáneo al elemento en el espacio 1 (índice base 0)
const tercerElemento = estanteNumerado[2]; // "Reloj"

🇺🇸 English version

Nos indica qué resultado estamos esperando al ejecutar la unidad de código bajo la situación simulada.

/** En este ejemplo las tres secciones del nombre están en el mismo texto
 * Avión es la unidad bajo pruebas
 * despegar sin parámetros es la situación a probar
 */
test("Avión, despegar sin parámetros, el estado del avión debe ser VOLANDO luego del despegue", () => {});

/** En este ejemplo la primera sección del nombre de la prueba está
 * en un grupo ya que se van a realizar varias pruebas sobre la misma
 * unidad
 * despegar sin parámetros es la situación a probar
 */
group("Avion", () => {
  test("despegar sin parámetros, el estado del avión debe ser VOLANDO luego del despegue", () => {});

  test("despegar con parámetro hayLluvia definido en true, el estado del avión debe ser VOLANDO luego del despegue", () => {});
});

🇺🇸 English version

Nos indica específicamente qué caso vamos a validar en la prueba, incluyendo los detalles que la hacen relevante.

/** En este ejemplo las tres secciones del nombre están en el mismo texto
 * Avión es la unidad bajo pruebas
 * Las xxx simbolizan las demás secciones
 */
test("Avión, despegar sin parámetros, xxx", () => {});

/** En este ejemplo la primera sección del nombre de la prueba está
 * en un grupo ya que se van a realizar varias pruebas sobre la misma
 * unidad
 * Las xxx simbolizan las demás secciones
 */
group("Avion", () => {
  test("despegar sin parámetros, xxx", () => {});

  test("despegar con parámetro hayLluvia definido en true, xxx", () => {});
});

🇺🇸 English version

Nos indica específicamente cuál es la unidad que estamos sometiendo a prueba.

La unidad puede estar en el mismo texto que las demás secciones o separado en un grupo si vamos a crear varias pruebas unitarias para la misma unidad.

/** En este ejemplo las tres secciones del nombre están en el mismo texto
 * Las xxx simbolizan las demás secciones
 */
test("Avión, xxx, xxx", () => {});

/** En este ejemplo la primera sección del nombre de la prueba está
 * en un grupo ya que se van a realizar varias pruebas sobre la misma
 * unidad
 * Las xxx simbolizan las demás secciones
 */
group("Avion", () => {
  test("xxx, xxx", () => {});

  test("xxx, xxx", () => {});
});

🇺🇸 English version

• Unidad bajo prueba: ¿Qué unidad estamos probando?
• Situación o entradas a la unidad: ¿Qué situación estamos simulando?
• Efecto esperado: ¿Qué resultado espero?

🇺🇸 English version

Solo debe validarse un único punto de salida por cada prueba unitaria y en ese punto de salida es que se enfoca esta sección.

test("El estado del avión debe ser VOLANDO luego del despegue", () => {
  /// Arreglar
  const motorFalso: IMotor = new MotorFalso();
  const tanqueDeCombustibleFalso: ITanque = new TanqueFalso();
  const avion: Avion = new Avion(motorFalso, tanqueDeCombustibleFalso);

  /// Actuar
  avion.despegar();

  /**
   * Notar que claramente demarcamos la sección
   * Afirmar y validamos en ella que el resultado
   * obtenido sea equivalente al resultado esperado
   */

  /// Afirmar
  assert(avion.estadoActual, EstadoAvion.VOLANDO);
});

🇺🇸 English version

test("El estado del avión debe ser VOLANDO luego del despegue", () => {
  /// Arreglar
  const motorFalso: IMotor = new MotorFalso();
  const tanqueDeCombustibleFalso: ITanque = new TanqueFalso();
  const avion: Avion = new Avion(motorFalso, tanqueDeCombustibleFalso);

  /**
   * Notar que claramente demarcamos la sección
   * Actuar e invocamos la unidad de código que
   * vamos a probar
   */

  /// Actuar
  avion.despegar();

  /// Resto de la prueba
});

🇺🇸 English version

test("El estado del avión debe ser VOLANDO luego del despegue", () => {
  /**
   * Notar que claramente demarcamos la sección
   * Arreglar e inicializamos en ella todas las
   * dependencias requeridas para crear la unidad
   * que vamos a probar (Un avión en este caso)
   */

  /// Arreglar
  const motorFalso: IMotor = new MotorFalso();
  const tanqueDeCombustibleFalso: ITanque = new TanqueFalso();
  const avion: Avion = new Avion(motorFalso, tanqueDeCombustibleFalso);

  /// Resto de la prueba
});

🇺🇸 English version

Cada letra representa una sección:

• Arreglar: Las dependencias para simular la situación a validar.
• Actuar: Ejecute la unidad de código.
• Afirmar: Que el resultado final sea el esperado.

Se sugiere que cada sección esté bien demarcada en la prueba unitaria.

🇺🇸 English version

Permite controlar a nuestro antojo la información recibida por la unidad de código.

Pueden existir varios Stub en una prueba.

Ya que inserta información a la prueba NO SE HACEN VALIDACIONES SOBRE STUBS.

class Persona {
  constructor(private _nombre: string, private _apellido: string) {}

  public get nombre() {
    return this._nombre;
  }

  public get apellido() {
    return this._apellido;
  }
}

/**
 * Interfaz requerida para leer personas desde una
 * base de datos
 * */
interface ILectorDePersonasDeBD {
  leerTodasLasPersonas(): Promise<Array<Persona>>;
}

/**
 * Implementación de un Stub de ILectorDePersonasDeBD
 * Con este stub podemos simular que una base de datos
 * retorna ciertas personas
 */
class StubLectorDePersonasDeBD implements ILectorDePersonasDeBD {
  constructor(private personas: Array<Persona>) {}

  async leerTodasLasPersonas(): Promise<Persona[]> {
    return this.personas;
  }
}

/**
 * Clase real que vamos a probar
 */
class MapeadorDePersonas {
  /**
   * Inicializa una instancia de MapeadorDePersonas
   * @param lectorDePersonasDeBD Fuente de datos desde la cual leer personas
   */
  constructor(private lectorDePersonasDeBD: ILectorDePersonasDeBD) {
    /**
     * Por favor note que estamos esperando una instancia de ILectorDePersonasDeBD
     * Éste es el truco que nos permite enviar un Stub para simular una base de
     * datos real con nuestros datos falsos
     */
  }

  /** Método de MapeadorDePersonas que queremos probar*/
  async mapearPersonaANombreCompleto(): Promise<Array<String>> {
    const personas = await this.lectorDePersonasDeBD.leerTodasLasPersonas();

    return personas.map(
      (persona: Persona) => `${persona.nombre} ${persona.apellido}`
    );
  }
}

/** Inicio de la pruebas */

/** Inicializar las personas para la prueba */
const enriqueBunbury = new Persona("Enrique", "Bunbury");
const pedroInfante = new Persona("Pedro", "Infante");

/** Crear un Stub para simular que dos personas son leídas desde la base de datos a
 * la instancia de MapeadorDePersonas
 */
const stubLectorDePersonasDeBD: ILectorDePersonasDeBD =
  new StubLectorDePersonasDeBD([enriqueBunbury, pedroInfante]);

/** Enviamos el StubLectorDePersonasDeBD al MapeadorDePersonas a través del constructor*/
const mapeadorDePersonas: MapeadorDePersonas = new MapeadorDePersonas(
  stubLectorDePersonasDeBD
);

/** Llamamos el método mapearPersonaANombreCompleto para validar que está mapeando correctamente
 * cada persona a un nombre completo
 */
mapeadorDePersonas.mapearPersonaANombreCompleto().then((nombresCompletos) => {
  const expectedFullNames = ["Enrique Bunbury", "Pedro Infante"];
  nombresCompletos.forEach((item, index) => {
    /** Simula la validación de la prueba */
    item === expectedFullNames[index];
  });
});

/** Fin de la prueba */

🇺🇸 English version

Permite validar esta información.

Solo puede existir máximo UN MOCK en una prueba, ya que simula un punto de salida y solo se valida uno por prueba unitaria.

/** Interfaz que define una dependencia externa */
interface IRegistrador {
  registrarInfo(info: string);
}

/** Implementación real de la interfaz IRegistrador */
class RegistradorReal implements IRegistrador {
  public registrarInfo(info: string) {
    console.log(info);
  }
}

/** Implementacióon Mock para verificar que
 * Calculadora.add está registrando correctamente */
class RegistradorMock implements IRegistrador {
  /** Campo privado para guardar la última información registrada */
  private informacionRecibidaParaRegistrar: string;

  /** Método definido por la interfaz IRegistrador*/
  public registrarInfo(info: string) {
    /** Asigna la info recibida a 
     * this.informacionRecibidaParaRegistrar para que podamos 
     * verificar más tarde que Calculadora.sumar envióla info correcta
     */
    this.informacionRecibidaParaRegistrar = info;
  }

  /** Permite el acceso para validar la última información recibida */
  public get informacionRecibida(): string {
    return this.informacionRecibidaParaRegistrar;
  }
}

class Calculadora {
  /** Constructor que recibe la implementación de IRegistrador */
  constructor(private registrador: IRegistrador) {}

  public sumar(sumando: number, otroSumando: number): number {
    /** Usa la implementación de IRegistrador recibida para registrar
     * la información relacionada a la suma*/
    this.registrador.registrarInfo(`Sumará ${sumando} y ${otroSumando}`);
    return sumando + otroSumando;
  }
}

/** Inicio de la prueba */

/** Inicializa un objeto RegistradorMock para validar que
 * Calculadora está registrando los datos correctamente
 */
const registradorMock: RegistradorMock = new RegistradorMock();
/** Envía el objeto RegistradorMock a Calculadora a través del constructor*/
const calculadora: Calculadora = new Calculadora(registradorMock);
/** Llamado al método sumar para validar que está registrando
 * correctamente la información */
calculadora.sumar(4, 5);

/** Valida que la información registrada es la que se espera */
registradorMock.informacionRecibida === "Sumará 4 y 5";

/** Fin de la prueba */

🇺🇸 English version

Objeto falso que nos ayuda a simular la situación que necesitamos para una prueba unitaria.

Tipos:

• Mock
• Stub

No son necesarios para las pruebas pero son muy útiles para aquellos casos en los que usar un objeto real es complejo para la situación que queremos simular.

🇺🇸 English version

• Una base de datos
• Una API HTTP
• Una llamada RPC

function sumaConRegistro(
  sumando: number,
  otroSumando: number,
  registrador: IRegistrador
): number {
  /** Punto de salida => llamado a dependencia externa */
  registrador.log(`Sumará: ${valorActual} + ${sumando}`);

  return otroSumando + sumando;
}

Para validarla se usa un doble de pruebas, en este caso un mock.

🇺🇸 English version

Para validar el resultado debemos acceder al estado que haya cambiado, así que requiere tres pasos:

• Ejecutar la unidad de código
• Acceder al estado que haya cambiado
• Validar que tenga el valor que esperamos

/** Estado que es cambiado */
let valorActual = 0;

/** Unidad de código que tiene un efecto secundario.
 * Cambia valorActual
 */
function sumar(sumando: number): void {
  /**
   * Punto de salida => Efecto secundario, Cambio de estado
   */
  valorActual += sumando;
}

/**
 * Método de acceder el estado actual
 */
function obtenerValorActual(): number {
  return valorActual;
}

/** Ejecutar unidad de código */
sumar(5);

/** Acceder al estado que cambia */
const valorAcumulado = obtenerValorActual();
/** Validar que el valor obtenido sea el esperado */
valorAcumulado === 5;

🇺🇸 English version

Es el punto de salida más fácil de validar ya que, al obtener el resultado retornado por la unidad de código, podemos compararlo con el resultado esperado.

/**
 * Es común indicar el tipo de retorno en el punto de entrada (firma)
 * En este caso es el último ```number``` el que especifica 
 * qué tipo retorna la unidad de código
 */
function sumar(sumando: number, otroSumando: number): number {
  /** Punto de salida valor de retorno */
  return sumando + otroSumando;
}

🇺🇸 English version

Resultado (verificable externamente) obtenido al ejecutar una unidad de código.

Tipos (RED):

• Retorno, valor de. (Más fácil de validar)
• Estado, cambio de
• Dependencia externa, llamado a. (Más difícil de validar)

let valorActual = 0;

function sumaConRegistro(sumando: number, registrador: IRegistrador): number {
  /** Punto de salida 1 => llamado a dependencia externa (D) */
  registrador.log(`Sumará: ${valorActual} + ${sumando}`);
  /** Punto de salida 2 => cambio de estado (E) */
  valorActual += sumando;

  /** Punto de salida 3 => valor de retorno (R) */
  return valorActual;
}

Toda unidad de código tiene punto(s) de salida.

Solo se valida un punto de salida por prueba unitaria

🇺🇸 English version

Puede ser tan complejo como se requiera, llamando múltiples funciones, módulos, etc.

function funcionCompleja(): number {
  /**
   * Inicio del cuerpo de la unidad de código
   */
  const primerValorDeRetorno = llamarOtraFuncion();
  const preResultado = modulo1.funcionExterna(primerValorDeRetorno);
  const resultado = preResultado.calcular();

  return resultado;
  /**
   * Inicio del cuerpo de la unidad de código
   */
}

🇺🇸 English version

Indica el nombre, parámetros recibidos y el tipo de retorno obtenido al ejecutar la unidad de código.

Una unidad de código SOLO TIENE UN PUNTO DE ENTRADA.

/** Entry point */
function sumar(sumando: number, otroSumando: number): number {
  return sumando + otroSumando;
}

🇺🇸 English version

Instrucciones ejecutadas desde la invocación del punto de entrada de un proceso hasta su terminación con un resultado verificable a través de uno o varios puntos de salida.

Composición:

• Punto de entrada
• Cuerpo
• Punto(s) de salida

class Calculadora {
  private resultadoAcumulado: number = 0;

  // Punto de entrada para la unidad de código *sumar*
  public sumar(sumando: number): number {
    /**
     * Inicio del cuerpo de la unidad de código
     */

    // Punto de salida
    this.resultadoAcumulado += sumando;

    // Otro punto de salida
    return this.resultadoAcumulado;

    /**
     * Fin del cuerpo de la unidad de código
     */
  }
}

Ejemplos:

• Una función
• Un método de un objeto
• Una funcionalidad de un módulo.

🇺🇸 English version

Valida que una unidad de código se comporte correctamente en una situación simulada.

Características:

• MUY rápidas
• Correr 100% en memoria
• Replicable en cualquier entorno
• Independiente de otras pruebas unitarias
• Antes, durante y después del desarrollo
• Solo valida una condición (por prueba unitaria): RED

Estructura:

AAA

Estructura del nombre:

USE

🇺🇸 English version