// A shelf with three fixed slots
const numberedShelf: string[] = ["Book", "Photo Frame", "Clock"];

// Instantly access the item at slot 0 (0-indexed)
const item = numberedShelf[0]; // "Book"

// Instantly access the item at slot 1 (0-indexed)
const item = numberedShelf[1]; // "Photo Frame"

// Instantly access the item at slot 2 (0-indexed)
const item = numberedShelf[2]; // "Clock"

🇨🇴 Versión en Español

It specifies what's the expected result after executing the unit of code under the simulated scenario.

/** In this example the three sections of the name are in the same text.
 * Airplane is the Unit under test
 * takeOff without parameters is the scenario under test
 */
test("Airplane, takeOff without parameters, the airplane state should be FLYING after takeoff", () => {});

/** In this example the first section of the test name is in a group
 * because there will be multiple tests on the same unit.
 * takeOff without parameters is the scenario under test
 */
group("Airplane", () => {
  group("takeOff without parameters, the airplane state should be FLYING after takeoff", ()=>);

  test("takeOff with isRaining parameter set to true, , the airplane state should be FLYING after takeoff", () => {});
});

🇨🇴 Versión en Español

It specifies which case we're going to verify in the test including the details that make it relevant.

/** In this example the three sections of the name are in the same text.
 * Airplane is the Unit under test
 * The xxx refer to the other section
 */
test("Airplane, takeOff without parameters, xxx", () => {});

/** In this example the first section of the test name is in a group
 * because there will be multiple tests on the same unit.
 * The xxx refer to the other sections
 */
group("Airplane", () => {
  group("takeOff without parameters, xxx", ()=>);

  test("takeOff with isRaining parameter set to true, xxx", () => {});
});

🇨🇴 Versión en Español

It specifies which is the unit that we're currently testing.

The unit can be in the same text as the other sections or separated in a group if we're going to create multiple unit tests for the same unit of code.

/** In this example the three sections of the name are in the same text.
 * The xxx refer to the other sections
 */
test("Airplane, xxx, xxx", () => {});

/** In this example the first section of the test name is in a group
 * because there will be multiple tests on the same unit.
 * The xxx refer to the other sections
 */
group("Airplane", () => {
  test("xxx, xxx", () => {});

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

🇨🇴 Versión en Español

• Unit under test: Which unit are we testing?
• Scenario or inputs to the unit: What situation are we simulating?
• Expected value: What's the expected result?

🇨🇴 Versión en Español

Only one exit point must be verified for each unit test and it's that exit point this section is focused on.

test("the airplane state should be FLYING after takeoff", () => {
  /// Arrange
  const fakeEngine: IEngine = new FakeEngine();
  const fakeFuelTank: ITank = new FakeTank();
  const airplane: Airplane = new Airplane(fakeEngine, fakeFuelTank);

  /// Act
  airplane.takeoff();

  /**
   * Notice that we clearly mark the Assert section
   * and we compare the test actual result with
   * the expected result
   */

  /// Assert
  assert(airplane.currentStatus, AirplaneStatus.FLYING);
});

🇨🇴 Versión en Español

test("the airplane state should be FLYING after takeoff", () => {
  /// Arrange
  const fakeEngine: IEngine = new FakeEngine();
  const fakeFuelTank: ITank = new FakeTank();
  const airplane: Airplane = new Airplane(fakeEngine, fakeFuelTank);

  /**
   * Notice that we clearly mark the Act section
   * and we invoke the unit of code we're going to
   * test
   */

  /// Act
  airplane.takeoff();

  /// Rest of the test
});

🇨🇴 Versión en Español

test("the airplane state should be FLYING after takeoff", () => {
  /**
   * Notice that we clearly mark the Arrange section
   * and we initialize in that section all the required
   * dependencies for creating the unit that we'll be
   * testing (An Airplane instance, in this case)
   */

  /// Arrange
  const fakeEngine: IEngine = new FakeEngine();
  const fakeFuelTank: ITank = new FakeTank();
  const airplane: Airplane = new Airplane();

  /// Rest of the test
});

🇨🇴 Versión en Español

Each letter stands for a section:

• Arrange: The dependencies to simulate the situation to verify.
• Act: Execute the unit of code.
• Assert: That the final result is as expected.

It's suggested that each section is well marked in the unit test.

🇨🇴 Versión en Español

It lets us control the info received by the unit of code.

Multiple Stubs can exist in a test.

Given that it inserts information into the test WE DO NOT VALIDATE OVER STUBS.

class Person {
  constructor(private _name: string, private _lastname: string) {}

  public get name() {
    return this._name;
  }

  public get lastname() {
    return this._lastname;
  }
}

/**
 * Interface required for reading people from a db
 * */
interface IPersonDBReader {
  readAllPeople(): Promise<Array<Person>>;
}

/**
 * Stub implementation for IPersonDBReader
 * With this stub we can simulate that a DB returned certain people
 */
class StubPersonDBReader implements IPersonDBReader {
  constructor(private people: Array<Person>) {}

  async readAllPeople(): Promise<Person[]> {
    return this.people;
  }
}

/**
 * Real class that we're going to test
 */
class PersonMapper {
  /**
   * Initializes a PersonMapper instance
   * @param _personDBReader data source to read people from
   */
  constructor(private _personDBReader: IPersonDBReader) {
    /**
     * Please notice that we're expecting an IPersonDBReader instance.
     * That is the actual trick that allows us to send a Stub to simulate
     * a real DB with our fake data
     */
  }

  /** Method from PersonMapper that we want to test */
  async mapPersonToFullName(): Promise<Array<String>> {
    const people = await this._personDBReader.readAllPeople();

    return people.map((person: Person) => `${person.name} ${person.lastname}`);
  }
}

/** Test Beginning */

/** Initialize two people for the test */
const freddieMercury = new Person("Freddie", "Mercury");
const brianMay = new Person("Brian", "May");

/** Create a Stub to simulate that two people are read from the DB into the PersonMapper*/
const stubPersonDBReader: IPersonDBReader = new StubPersonDBReader([
  freddieMercury,
  brianMay,
]);

/** Send StubPersonDBReader object to PersonMapper via constructor */
const personMapper: PersonMapper = new PersonMapper(stubPersonDBReader);

/** Call mapPersonToFullName method to test that it's correctly mapping each person to a fullName */
personMapper.mapPersonToFullName().then((fullNames) => {
  const expectedFullNames = ["Freddie Mercury", "Brian May"];
  fullNames.forEach((item, index) => {
    /** Simulate test result validation */
    item === expectedFullNames[index];
  });
});

/** Test End */

🇨🇴 Versión en Español

It allows to validate that information..

It can only exist ONE MOCK at most per test, given that it simulates an exit point and only one is verified per unit test

/** Interface tha defines an external dependency */
interface ILogger {
  logInfo(info: string);
}

/** Real implementation for ILogger interface */
class RealLogger implements ILogger {
  public logInfo(info: string) {
    console.log(info);
  }
}

/** Mock implementation to verify
 * Calculator.add is logging properly */
class MockLogger implements ILogger {
  /** Private field to store last logged info */
  private receivedInfoToLog: string;

  /** Method defined by ILogger interface */
  public logInfo(info: string) {
    /** Assign received info to this.receivedInfoToLog
     * so we can later verify that Calculator.add sent
     * the right info
     */
    this.receivedInfoToLog = info;
  }

  /** Give access to validate latest logged info */
  public get loggedInfo(): string {
    return this.receivedInfoToLog;
  }
}

class Calculator {
  /** Costructor receiving an ILogger implementation */
  constructor(private logger: ILogger) {}

  public add(summand: number, otherSummand: number): number {
    /** Uses received ILogger implementation to log info
     * related to addition */
    this.logger.logInfo(`Will add ${summand} and ${otherSummand}`);
    return summand + otherSummand;
  }
}

/** Test Beginning */

/** Initializes a MockLogger object to validate
 * Calculator is properly logging data */
const mockLogger: MockLogger = new MockLogger();
/** Send MockLogger object to Calculator via constructor */
const calculator: Calculator = new Calculator(mockLogger);
/** Call add method to test that it's correctly logging the info */
calculator.add(4, 5);

/** Verify that the logged info is as expected */
mockLogger.loggedInfo === "Will add 4 and 5";

/** Test End */

🇨🇴 Versión en Español

Fake object that help us simulate the situation required for a unit test.

Types:

• Mock
• Stub

They are not mandatory for tests but are very useful for those cases where using a real object is complex for the situation we want to simulate.

🇨🇴 Versión en Español

• Database
• HTTP API
• RPC

function additionWithLogging(
  summand: number,
  otherSummand: number,
  logger: ILogger
): number {
  /** Exit point => external dependency call */
  logger.log(`Will add: ${currentValue} + ${summand}`);

  return otherSummand + summand;
}

To verify it a test double is used, in this case a mock.

🇨🇴 Versión en Español

To validate the result we must access the state that has changed, so it is compromised of three steps:

• Execute the unit of code
• Access the changed state
• Verify the value is as expected

/** State that is changed */
let currentValue = 0;

/** Unit of code that has an effect.
 * It changes currentValue
 */
function add(summand: number): void {
  /**
   * Exit point => Effect, Change of state
   */
  currentValue += summand;
}

/**
 * Way to access current state
 */
function getCurrentValue(): number {
  return currentValue;
}

/** Execute unit of code */
sumar(5);

/** Access changed state */
const valorAcumulado = obtenerValorActual();
/** Verify obtained value is what we expect */
valorAcumulado === 5;

🇨🇴 Versión en Español

It's the easiest exit point to verify because, after getting the value returned by the unit of code, we can compare it with the expected result.

/** 
 * It's common to point the return type in the entry point (signature)
 * In this case is the last ```number``` that specifies 
 * what type this unit of code returns.
 */
function add(summand: number, otherSummand: number): number {
  /** Return value exit point */
  return summand + otherSummand;
}

🇨🇴 Versión en Español

Result (verifiable externally) obtained by executing a unit of code.

Types (RED):

• Return value. (Easiest to verify).
• Effect, change of state
• Dependency, call to external. (Hardest to verify)

let currentValue = 0;

function additionWithLogging(summand: number, logger: ILogger): number {
  /** Exit point 1 => external dependency call (D) */
  logger.log(`Will add: ${currentValue} + ${summand}`);
  /** Exit point 2 => effect, change of state (E) */
  currentValue += summand;

  /** Exit point 3 => return value (R) */
  return currentValue;
}

Every unit of code has exit point(s).

Only one exit point is verified per unit test

🇨🇴 Versión en Español

It can be as complex as required, calling multiple functions, modules, etc.

function complexFunction(): number {
  /**
   * Beginning of the unit of code's body
   */
  const firstReturnValue = calToAnotherFunction();
  const preResult = module1.externalFunction(firstReturnValue);
  const result = preResult.calculate();

  return result;
  /**
   * End of the unit of code's body
   */
}

🇨🇴 Versión en Español

Indicates the name, received parameters and the return type obtained when the unit of code is executed.

A unit of code ONLY HAS ONE ENTRY POINT

/** Entry point */
function add(summand: number, otherSummand: number): number {
  return summand + otherSummand;
}

🇨🇴 Versión en Español

Instructions executed from a process' entry point until its ending with a verifiable result through one or multiple exit points.

Composition:

• Entry point
• Body
• Exit point(s)

class Calculator {
  private currentResult: number = 0;

  // Entry point for the unit of code *add*
  public add(summand: number): number {
    /**
     * Beginning of the unit of code's body
     */

    // Exit point
    this.currentResult += summand;

    // Another exit point
    return this.currentResult;

    /**
     * End of the unit of code's body
     */
  }
}

Examples:

• A function
• An object method
• A module feature

🇨🇴 Versión en Español

Validates that a unit of code behaves correctly in a simulated situation.

Features:

• VERY fast
• Run 100% in memory
• Replicable in any environment
• Independent from other unit tests
• Run before, during and after development
• Only validates one condition (per unit test): RED

Structure:

AAA

Name structure:

USE

🇨🇴 Versión en Español