Skip to content

06. JUnit, Maven y Mockito

Jump to bottom
Melissa Diaz edited this page Jan 23, 2025 · 1 revision

JUnit-MAVEN-MOCKITO

Pruebas unitarias

Permiten examinar la funcionalidad de métodos o clases de manera aislada, sin tener en cuenta sus dependencias. Garantizando que cada componente trabaje correctamente y cumpla con sus objetivos específicos.

JUnit

JUnit es un framework popular para realizar pruebas unitarias en Java.

Estructura de una clase de prueba:

package test;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import src.Ejercicio1;

public class Ejercicio1Test {

    @Test
    public void testMetodo() {
        // Ejecuta el método a probar
        Integer resultado = Ejercicio1.metodo(2);
    
        // Verifica si el resultado es el esperado
        Assertions.assertEquals(4, resultado);
    }
}

La clase Ejercicio1Test verifica el funcionamiento del método metodo() de la clase Ejercicio1. El método de prueba está anotado con @Test, indicando que debe ejecutarse como una prueba. Se utiliza Assertions.assertEquals() para comparar el resultado del método con el valor esperado; si coinciden, la prueba pasa, y si no, JUnit informa el fallo, detallando la diferencia. Esta estructura permite validar que el código funciona correctamente sin necesidad de un método main.

Convenciones de Nomenclaturas

Las convenciones de nomenclatura son reglas que facilitan la legibilidad, colaboración y estructura del código en proyectos. A continuación, se detallan las más comunes:

Clases
  • Regla: Agregar Test al final del nombre de la clase principal.
  • Ejemplo: Calculadora → CalculadoraTest.
package test;
public class CalculadoraTest {
    // pruebas unitarias para Calculadora
}
Métodos
  1. testMethodName: Simple y antigua.
@Test
void testSuma() {
	// código de prueba aquí
}
  1. should_MethodName_ExpectedBehavior_GivenCondition: Descriptiva. Formato should-when-given.
@Test
void should_Suma_ReturnCorrectSum_GivenMultipleNumberPairs() {
	// código de prueba aquí
}
  1. MethodName_GivenCondition_ExpectedBehavior: Condición antes del resultado. Leer como secuencia causa y efecto.
@Test
void suma_GivenMultipleNumberPairs_ReturnsCorrectSum() {
	// código de prueba aquí
}
  1. given_Precondition_When_StateUnderTest_Then_ExpectedBehavior: Enfoque Given-When-Then. Muy descriptiva.
@Test
void given_MultipleNumberPairs_When_SumaCalled_Then_ReturnsCorrectSum() {
	// código de prueba aquí
}
  1. MethodName_Scenario_ExpectedResult: Útil para pruebas con diferentes escenarios. Prueba lo que prueba
@Test
void suma_MultipleNumberPairs_CorrectSum() {
	// código de prueba aquí
}
@DisplayName

(JUnit 5)

Permite nombres descriptivos en pruebas. Útil para asignar un nombre más descriptivo.

@Test
@DisplayName("Suma de múltiples pares de números: retorna suma correcta")
void testSuma() {
    // código de prueba aquí
}

Aserciones

Las aserciones (afirmaciones), son declaraciones que verifican si cierta condición es verdadera.

JUnit 5 proporciona la clase org.junit.jupiter.api.Assertions, que incluye una variedad de métodos estáticos para realizar diferentes tipos de afirmaciones:

Ejemplos comunes:

  1. assertEquals(expected, actual)
    Verifica si dos valores son iguales. Si no lo son, la prueba fallará.

    @Test
void testSuma() {
    // La suma debería ser 5
    assertEquals(5, 2 + 3);
}

  2. assertNotEquals(expected, actual)
    Verifica si dos valores NO son iguales. Si lo son, la prueba fallará.

    @Test
void testSuma() {
	// La suma no debería ser 6
    assertNotEquals(6, 2 + 3);
}

  3. assertTrue(condition)
    Verifica si una condición es verdadera. Si no lo es, la prueba fallará.

    @Test
void testIsEven() {
    // 4 debería ser par
    assertTrue(4 % 2 == 0);
}

  4. assertFalse(condition)
    Verifica si una condición es falsa. Si no lo es, la prueba fallará.

    @Test
void testIsOdd() {
    // 4 no debería ser impar
    assertFalse(4 % 2 != 0);
}

  5. assertNull(value)
    Verifica si un valor es nulo. Si no lo es, la prueba fallará.

    @Test
void testNullValue() {
    String str = null;
    // La variable debería ser nula
    assertNull(str);
}

  6. assertNotNull(value)
    Verifica si un valor NO es nulo. Si lo es, la prueba fallará.

    @Test
void testNotNullValue() {
    String str = "Hola mundo";
    // La variable no debería ser nula
    assertNotNull(str);
}

  7. assertSame(expected, actual)
    Verifica si dos referencias de objetos apuntan al mismo objeto. Si no lo hacen, la prueba fallará.

    @Test
void testSameObject() {
    String str1 = "Hola mundo";
    String str2 = str1;
    // Las variables deberían referenciar al mismo objeto
    assertSame(str1, str2);
}

  8. assertNotSame(expected, actual)
    Verifica si dos referencias de objetos NO apuntan al mismo objeto. Si lo hacen, la prueba fallará.

    @Test
void testNotSameObject() {
    String str1 = new String("Hola mundo");
    String str2 = new String("Hola mundo");
    // Las variables no deberían referenciar al mismo objeto.
    assertNotSame(str1, str2);
}

  9. assertArrayEquals(expectedArray, actualArray)
    Verifica si dos arrays son iguales. Si no lo son, la prueba fallará.

    @Test
void testArrayEquality() {
    int[] array1 = {1, 2, 3};
    int[] array2 = {1, 2, 3};
    // Los arrays deberían ser iguales
    assertArrayEquals(array1, array2);
}

  10. assertThrows(expectedType, executable)
    Verifica si una operación lanza una excepción del tipo esperado.

    @Test
void testException() {
// Debería lanzar ArithmeticException
    assertThrows(ArithmeticException.class, () -> {
        int division = 5 / 0;
    });
}

  11. assertEquals(double expected, double actual, double delta)
    Compara números de punto flotante permitiendo una diferencia de precisión.

    @Test
public void testSquareRoot() {
    // El valor de la raíz cuadrada de 4 debería ser 2
    assertEquals(2.0, Math.sqrt(4.0));
    // La raíz cuadrada de 2 debería ser cercana a 1.4142
    assertEquals(1.4142, Math.sqrt(2.0), 0.0001);
}

Note

Todos los métodos mencionados anteriormente también tienen una sobrecarga que acepta un parámetro adicional de tipo String, lo que permite agregar un mensaje personalizado que se imprimirá en caso de que la afirmación falle.

@Test
void testSuma() {
	assertEquals(5, 2 + 3, "La suma debería ser 5");
}

Estrategia AAA (Arrange, Act, Assert)

Esta estructura es comúnmente utilizada para organizar y escribir pruebas unitarias.

  • Arrange: Configura el entorno.
  • Act: Ejecuta el método bajo prueba.
  • Assert: Verifica resultados esperados.
@Test
void testSuma() {
    // Arrange
    int numero1 = 4;
    int numero2 = 5;

    // Act
    int resultado = Calculadora.suma(numero1, numero2);

    // Assert
    assertEquals(9, resultado, "La suma de 4 y 5 debería ser 9");
}

En el ejemplo, se puede observar lo siguiente:

  • Arrange: Se definen dos números que serán sumados.
  • Act: Se llama al método estático suma() de la clase Calculadora, pasando los dos números como argumentos.
  • Assert: Se verifica que el resultado de la suma sea igual a 9. En caso contrario, la prueba fallará y se mostrará el mensaje "La suma de 4 y 5 debería ser 9".

Ciclo de Vida de Pruebas Unitarias

El ciclo de vida de las pruebas unitarias se refiere al proceso y los pasos que JUnit sigue cuando se ejecutan los tests de una clase. Estos pasos pueden ser personalizados mediante el uso de anotaciones específicas:

Controla la configuración y limpieza antes o después de las pruebas. Anotaciones clave:

  • @BeforeAll: Ejecuta antes de todas las pruebas (método estático).
  • @BeforeEach: Ejecuta antes de cada prueba.
  • @Test: Declara un método de prueba.
  • @AfterEach: Ejecuta después de cada prueba.
  • @AfterAll: Ejecuta después de todas las pruebas (método estático).
import org.junit.jupiter.api.*;

class MyTestClass {
    @BeforeAll
    static void initAll() {
        // Código para configurar el estado antes de todas las pruebas
        System.out.println("Configuración inicial antes de todas las pruebas");
    }

    @BeforeEach
    void setUp() {
        // Código para configurar antes de cada prueba
        System.out.println("Configuración antes de cada prueba");
    }
    
    @Test
    void myTest() {
        // Código de la prueba
        System.out.println("Ejecución de la prueba");
        Assertions.assertEquals(2, 1 + 1); // Ejemplo de una aserción
    }

    @AfterEach
    void tearDown() {
        // Código para limpiar el estado después de cada prueba
        System.out.println("Limpieza después de cada prueba");
    }

    @AfterAll
    static void tearDownAll() {
        // Código para limpiar el estado después de todas las pruebas
        System.out.println("Limpieza final después de todas las pruebas");
    }
}

Estas anotaciones simplifican el manejo del ciclo de vida de las pruebas, permitiendo configurar y limpiar estados de forma eficiente. Ayudan a reducir código repetitivo y mejoran la legibilidad y mantenibilidad de las pruebas.

Pruebas parametrizadas

Las pruebas parametrizadas en JUnit permiten ejecutar una misma prueba con diferentes datos de entrada, evitando duplicar código. Son ideales para lógica repetitiva, mejorando la legibilidad y mantenimiento de las pruebas.

Para crearla:

  1. Se utiliza la anotación @ParameterizedTest.
  2. Se proporcionan los datos de entrada utilizando una de las siguientes anotaciones de origen de datos: @ValueSource, @MethodSource, @CsvSource, @CsvFileSource, entre otras.

@ValueSource

Permite definir un conjunto de valores literales de un único tipo como argumentos para las pruebas.

@ParameterizedTest
@ValueSource(ints = {2, 3, 5, 7, 11, 13, 17, 19})
void testEsPrimo(int number) {
    assertTrue(Primos.esPrimo(number), "El número debería ser primo");
}

@MethodSource

Utiliza un método para proporcionar parámetros a las pruebas. El método debe ser estático y no tener parámetros.

@ParameterizedTest
@MethodSource("provideStrings")
void testWithExplicitLocalMethodSource(String argument) {
    assertNotNull(argument);
}

static String[] provideStrings() {
    return new String[] {"manzana", "banana"};
}

@CsvSource

Define parámetros para la prueba en formato CSV directamente en la anotación.

@ParameterizedTest
@CsvSource({"1, 2, 3", "2, 3, 5", "3, 5, 8"})
void testSuma(int num1, int num2, int expectedResult) {
    assertEquals(expectedResult, Calculadora.suma(num1, num2), "La suma debería ser correcta");
}

@CsvFileSource

Lee parámetros desde un archivo CSV externo.

@ParameterizedTest
@CsvFileSource(resources = "/test/day-week-data.csv", numLinesToSkip = 1) // Archivo day-week-data.csv
void testWithCsvFileSource(String dayWeek, Integer expectedResult) {
    Integer result = getNumberDay(dayWeek);
    assertEquals(expectedResult, result);
}

Repetición de pruebas en JUnit 5

JUnit 5 permite ejecutar automáticamente una prueba varias veces utilizando la anotación @RepeatedTest. Es útil para pruebas no deterministas o con datos aleatorios.

Ejemplo básico:

La prueba se repetirá 5 veces.

class MyTestClass {
    @RepeatedTest(5)
    void myRepeatedTest() {
        // Código de la prueba aquí...
    }
}

Control de repeticiones con RepetitionInfo:

RepetitionInfo permite acceder a la repetición actual y al número total de repeticiones.

class MyTestClass {
    @RepeatedTest(5)
    void myRepeatedTest(RepetitionInfo repetitionInfo) {
        int currentRepetition = repetitionInfo.getCurrentRepetition(); // Número actual de repetición
        int totalRepetitions = repetitionInfo.getTotalRepetitions();   // Total de repeticiones
        // Código de la prueba aquí...
    }
}
  • getCurrentRepetition(): Devuelve el número de la repetición actual.
  • getTotalRepetitions(): Devuelve el total de repeticiones configuradas.

MAVEN

Herramienta de gestión de proyectos que simplifica y automatiza el proceso de construccción, dependencias y despliegue de aplicaciones.

Está diseñada para manejar el ciclo de vida completo de un proyecto de software, desde la etapa de compilación hasta la etapa de prueba, empaquetado, y despliegue.

Estructura

Al crear un proyecto con Maven, se genera una estructura específica de directorios que organiza los archivos del proyecto:

maven

  • pom.xml: Archivo principal de configuración. Define dependencias, plugins, y perfiles de construcción del proyecto.
  • src/main/java/com/my-company/app/: Carpeta para el código fuente de la aplicación (reemplazar my-company y app con los nombres adecuados).
  • src/main/resources: Almacena recursos de la aplicación, como archivos de configuración y propiedades.
  • src/test/java/com/my-company/app/: Carpeta para el código fuente de las pruebas unitarias.
  • src/test/resources: Almacena recursos para las pruebas, como archivos de configuración o datos de prueba (por ejemplo, archivos CSV).
  • target/: Carpeta generada automáticamente para los archivos de compilación y salidas creadas por plugins de Maven.
  • target/classes: Contiene los archivos .class compilados tras la construcción del proyecto.

El archivo pom.xml que compartiste es una parte esencial de un proyecto Maven. Aquí tienes un resumen de su contenido y propósito:

Propósito de pom.xml

El archivo pom.xml (Project Object Model) es un archivo de configuración para proyectos Maven que sigue el enfoque de Convención sobre Configuración. Esto significa que:

  1. Proporciona una estructura estándar para todos los proyectos.
  2. Reduce la necesidad de configuraciones personalizadas.
  3. Aumenta la productividad y la interoperabilidad con herramientas y sistemas externos.
Estructura del archivo pom.xml

  1. Raíz del proyecto

    <project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    • Define el espacio de nombres y la versión del esquema XML.
    • Garantiza que el archivo sigue un formato válido.

  2. Versión del modelo

    <modelVersion>4.0.0</modelVersion>
    • Especifica la versión del modelo POM (siempre es 4.0.0 en Maven moderno).

  3. Identificación del proyecto

    <groupId>com.mycompany</groupId>
<artifactId>app</artifactId>
<version>1.0-SNAPSHOT</version>
    • <groupId>: Identifica la organización o grupo. Ejemplo: com.empresa.
    • <artifactId>: Nombre único del proyecto. Ejemplo: app.
    • <version>: Versión del proyecto. Ejemplo: 1.0-SNAPSHOT.

  4. Propiedades reutilizables

    <properties>
    <java.version>20</java.version>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
    • Facilita el uso de variables reutilizables, como la versión de Java.

  5. Dependencias

    <dependencies>
    <!-- Aquí puedes agregar las bibliotecas necesarias -->
</dependencies>
    • Especifica bibliotecas externas requeridas usando <groupId>, <artifactId> y <version>.

  6. Configuración de construcción

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
            </configuration>
        </plugin>
    </plugins>
</build>
    • <build>: Define cómo se debe compilar y construir el proyecto.
    • <plugins>: Especifica plugins adicionales para tareas específicas, como compilación.

Beneficios clave de Maven

  1. Menos configuración personalizada: Uso de convenciones predeterminadas.
  2. Estandarización: Estructura consistente en todos los proyectos.
  3. Interoperabilidad: Compatible con diversas herramientas y sistemas.
  4. Aumento de productividad: Configuración automática y más tiempo para el desarrollo.

Dependecias

Las dependencias en Maven son fundamentales para gestionar bibliotecas externas necesarias en un proyecto. Maven automatiza la descarga e integración de estas dependencias, asegurando un flujo de trabajo eficiente y organizado. Maven gestiona las dependencias al declararlas en el archivo pom.xml:

Ventajas:

  • Automatización: No se necesita descargar manualmente las librerías.
  • Colaboración: Otros desarrolladores pueden ejecutar el proyecto sin buscar las dependencias, ya que Maven las descarga automáticamente.
  • Limpieza: Las dependencias se almacenan fuera del directorio del proyecto, manteniéndolo ligero y organizado.

Ejemplo de Dependencia:

Para incluir JUnit 5:

<dependencies>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.3</version>
    <scope>test</scope>
  </dependency>
</dependencies>
  • Central: Maven busca dependencias en el repositorio central por defecto.
  • Local: Descargas se guardan en .m2/repository (en el directorio de usuario) para reutilización.
  • Personalizados: Se pueden configurar repositorios adicionales si es necesario.

Note

  • Maven también gestiona las dependencias de tus dependencias. Por ejemplo: Si A depende de B, y B depende de C, entonces C es una dependencia transitiva de A.

Alcances (Scopes):

El alcance (scope) indica en qué etapas del ciclo de vida de Maven se utilizará la dependencia:

  1. compile: Por defecto, necesaria en todas las fases.
  2. test: Solo para pruebas.
  3. runtime: Necesaria en ejecución, no en compilación.
  4. provided: Necesaria en compilación, pero se espera que esté disponible en tiempo de ejecución (por ejemplo, bibliotecas del servidor).
  5. system: Similar a provided, pero se debe especificar la ubicación del archivo JAR manualmente.

Ciclo de Vida en Maven

Maven tiene tres ciclos principales:

1. Default (Construcción del proyecto):

Fases principales:

  • validate: Verifica que el proyecto es válido.
  • compile: Compila el código fuente.
  • test: Ejecuta pruebas unitarias.
  • package: Empaqueta el proyecto en un JAR o WAR.
  • verify: Verificaciones de control de calidad.
  • install: Instala el paquete en el repositorio local.
  • deploy: Publica el paquete en un repositorio remoto.

Nota: Ejecutar una fase también ejecuta las anteriores. Por ejemplo, mvn install ejecutará validate, compile, test, etc.

2. Clean (Limpieza del proyecto):
  • clean: Elimina los archivos generados (carpeta target).
3. Site (Documentación del proyecto):
  • site: Genera documentación en target/site.
Plugins y Goals:
  • Plugins: Añaden funcionalidad específica al ciclo de vida. Ejemplo: compilación, ejecución de pruebas.
  • Goals: Son tareas individuales que ejecuta un plugin. Ejemplo: mvn compile ejecuta el goal compile del plugin del compilador.

Note

Comandos comunes:

  • Compilar: mvn compile
  • Empaquetar: mvn package
  • Instalar localmente: mvn install
  • Limpiar y compilar: mvn clean compile

Directorio target

  • target es el directorio donde Maven coloca los archivos generados al construir un proyecto.
    • mvn compile: Los archivos .class se ubican en target/classes.
    • mvn package: El archivo empaquetado resultante (JAR, WAR o EAR) se coloca en target.

Archivos empaquetados en Maven

  • JAR (Java Archive): Archivo ejecutable de Java. Necesita JRE para ejecutarse.
  • WAR (Web Application Archive): Contiene aplicaciones web Java y se despliega en servidores.
  • EAR (Enterprise Archive): Similar al WAR, pero para aplicaciones empresariales más complejas.

Para cambiar el tipo de paquete generado, configura <packaging> en el archivo pom.xml:

<packaging>war</packaging>

Arquetipos en Maven

  • Los arquetipos son plantillas para crear proyectos con una estructura predeterminada.
  • Ejemplo común: maven-archetype-quickstart, que incluye una clase principal y pruebas.

Comando para generar un proyecto desde un arquetipo:

mvn archetype:generate \
  -DgroupId=com.mycompany.app \
  -DartifactId=my-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false
  • DgroupId: Identificador del grupo (dominio inverso).
  • DartifactId: Nombre del proyecto.
  • DarchetypeArtifactId: Identificador del arquetipo.
Crear un arquetipo personalizado

  1. Crear un proyecto base: Define la estructura y configuración inicial.

  2. Descriptor del arquetipo: Archivo archetype-metadata.xml que indica qué incluir.

    <archetype-descriptor name="myArchetype">
  <fileSets>
    <fileSet filtered="true" packaged="true">
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.java</include>
      </includes>
    </fileSet>
  </fileSets>
</archetype-descriptor>

  3. Configurar el plugin en el pom.xml:

    <build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-archetype-plugin</artifactId>
      <version>3.2.0</version>
    </plugin>
  </plugins>
</build>

  4. Generar el arquetipo:

    • mvn archetype:create-from-project: Crea el arquetipo en target/generated-sources/archetype.
    • mvn install o mvn deploy: Instala el arquetipo en el repositorio local o remoto.

  5. Usar con mvn archetype:generate especificando groupId, artifactId y versión del arquetipo.

Mockito

Mockito es un framework de simulación (mocking) en Java ampliamente utilizado para desarrollar pruebas unitarias. Facilita la creación de objetos simulados, configuración de comportamientos, y la verificación de interacciones en pruebas de manera sencilla y flexible.

Instalación de Mockito

Para proyectos con Maven, agregar la siguiente dependencia al archivo pom.xml:

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>5.4.0</version>
  <scope>test</scope>
</dependency>

Uso de Mockito

  1. Creación de objetos simulados (mocks)
    Los objetos simulados actúan como sustitutos de objetos reales. Utiliza el método mock().

    List<String> mockedList = mock(List.class);

  2. Configuración de comportamientos
    Define qué debe hacer un objeto simulado al llamar métodos específicos con when().thenReturn().

    when(mockedList.get(0)).thenReturn("primer elemento");

  3. Verificación de interacciones
    Comprueba si un método se ha llamado, cuántas veces, y con qué argumentos.

    verify(mockedList).add("un elemento");

  4. Captura de argumentos
    Permite verificar los valores pasados a métodos del objeto simulado con ArgumentCaptor.

    ArgumentCaptor<String> argCaptor = ArgumentCaptor.forClass(String.class);
verify(mockedList).add(argCaptor.capture());
assertEquals("un elemento", argCaptor.getValue());

  5. Creación de objetos espías (spies)
    Los espías rastrean y modifican el comportamiento de un objeto real, manteniendo su implementación original.

    List<String> spyList = spy(new ArrayList<>());
spyList.add("elemento real");
verify(spyList).add("elemento real");

  6. Simulación de dependencias
    Mockito permite simular dependencias externas para aislar la unidad que se prueba.

    PaymentGateway mockPaymentGateway = mock(PaymentGateway.class);
when(mockPaymentGateway.processPayment(100.0)).thenReturn(true);
OrderProcessor orderProcessor = new OrderProcessor(mockPaymentGateway);
assertTrue(orderProcessor.processOrder(100.0));
verify(mockPaymentGateway).processPayment(100.0);

Ejemplo: Simulación de dependencias

Clase real:

public class OrderProcessor {
    private PaymentGateway paymentGateway;

    public OrderProcessor(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }

    public boolean processOrder(double amount) {
        return paymentGateway.processPayment(amount);
    }
}

Prueba:

@Test
public void testOrderProcessor() {
    PaymentGateway mockPaymentGateway = mock(PaymentGateway.class);
    when(mockPaymentGateway.processPayment(100.0)).thenReturn(true);

    OrderProcessor orderProcessor = new OrderProcessor(mockPaymentGateway);

    assertTrue(orderProcessor.processOrder(100.0));
    verify(mockPaymentGateway).processPayment(100.0);
}

Beneficios de Mockito

  • Pruebas más rápidas y fiables.
  • Aislamiento de dependencias externas.
  • Flexibilidad para configurar y verificar el comportamiento de objetos.

Clone this wiki locally