Entendiendo el Patrón Adaptador en TypeScript con Pruebas Unitarias
Entendiendo el Patrón Adaptador en TypeScript con Pruebas Unitarias
El patrón Adaptador es un patrón de diseño estructural utilizado para hacer que una interfaz sea compatible con otra. Permite que objetos…
Entendiendo el Patrón Adaptador en TypeScript con Pruebas Unitarias
El patrón Adaptador es un patrón de diseño estructural utilizado para hacer que una interfaz sea compatible con otra. Permite que objetos con interfaces incompatibles trabajen juntos. En este blog, exploraremos el patrón Adaptador en TypeScript y cómo implementar pruebas unitarias para garantizar su corrección.
Comprendiendo el Patrón Adaptador
El patrón Adaptador implica la creación de una clase, conocida como el adaptador, que actúa como un puente entre dos interfaces incompatibles. Permite que las clases con diferentes interfaces trabajen juntas de manera fluida. Este patrón es especialmente útil al integrar bibliotecas externas, trabajar con código heredado o garantizar la interoperabilidad.
Componentes del Patrón Adaptador
- Objetivo (Target): Esta es la interfaz con la que el código cliente espera trabajar.
- Adaptee: Esta es la clase que debe adaptarse para ajustarse a la interfaz objetivo.
- Adaptador: Esta es la clase que une la brecha entre el objetivo y el adaptee al implementar la interfaz objetivo y delegar las llamadas al adaptee.
Implementación del Patrón Adaptador en TypeScript
Consideremos un ejemplo práctico en el que queremos adaptar una clase que proporciona datos meteorológicos en grados Fahrenheit para que funcione con una clase que espera datos en grados Celsius. Aquí tienes el código TypeScript para este escenario:
// Interfaz objetivo
interface TemperaturaEnCelsius {
obtenerTemperaturaEnCelsius(): number;
}
// Adaptee
class TemperaturaEnFahrenheit {
constructor(private temperaturaEnFahrenheit: number) {}
obtenerTemperaturaEnFahrenheit(): number {
return this.temperaturaEnFahrenheit;
}
}
// Adaptador
class AdaptadorDeTemperatura implements TemperaturaEnCelsius {
constructor(private adaptee: TemperaturaEnFahrenheit) {}
obtenerTemperaturaEnCelsius(): number {
// Adaptar de Fahrenheit a Celsius
return (this.adaptee.obtenerTemperaturaEnFahrenheit() - 32) / 1.8;
}
}
En este ejemplo, la clase AdaptadorDeTemperatura nos permite utilizar la clase TemperaturaEnFahrenheit como si implementara la interfaz TemperaturaEnCelsius.
Implementación de Pruebas Unitarias para el Adaptador
Ahora, implementemos pruebas unitarias para garantizar la corrección de nuestra implementación del patrón Adaptador. Utilizaremos el popular framework de pruebas, Jest, para este propósito.
# Instalar Jest
npm install —save-dev jest @types/jest ts-jest
# Crear un archivo de pruebas, por ejemplo, temperatureAdapter.test.ts
Aquí tienes una prueba unitaria de muestra para nuestro AdaptadorDeTemperatura:
// temperatureAdapter.test.ts
import { TemperaturaEnFahrenheit, AdaptadorDeTemperatura } from ’./temperatureAdapter’;
describe(‘AdaptadorDeTemperatura’, () => {
it(‘debería adaptar la temperatura en Fahrenheit a Celsius’, () => {
const temperaturaFahrenheit = new TemperaturaEnFahrenheit(32); // 32°F
const adaptador = new AdaptadorDeTemperatura(temperaturaFahrenheit);
const resultado = adaptador.obtenerTemperaturaEnCelsius();
expect(resultado).toBe(0); // 0°C });
});
Para ejecutar las pruebas, agrega el siguiente script a tu archivo package.json:
“scripts”: {
“test”: “jest”
}
Luego, ejecuta las pruebas con npm test.
Conclusión
El patrón Adaptador es una herramienta valiosa para lograr la compatibilidad entre interfaces incompatibles en TypeScript. Al implementar pruebas unitarias, puedes asegurarte de que tus adaptadores funcionen correctamente, incluso a medida que tu código evoluciona. Este blog ha proporcionado una introducción al patrón Adaptador y ha demostrado cómo implementar pruebas unitarias en TypeScript para verificar su funcionalidad.
By Jaime Hernández on October 14, 2023.
Exported from Medium on March 15, 2025.
~devjaime