En este artículo, veremos cómo escribir código limpio y fácilmente comprobable en un estilo funcional utilizando el patrón de programación de Inyección de dependencias. La bonificación es el 100% de cobertura de prueba unitaria.

La terminología que se utilizará en el artículo.

El autor del artículo tendrá en cuenta precisamente esa interpretación de los siguientes términos, entendiendo que esta no es la verdad última y que otras interpretaciones son posibles.

• Inyección de dependencia
  Este es un patrón de programación que asume que las dependencias externas para funciones y fábricas de objetos provienen del exterior en forma de argumentos para estas funciones. La inyección de dependencias es una alternativa al uso de dependencias de un contexto global.
• Función de red
  Esta es una función, cuyo resultado depende solo de sus argumentos. Además, la función no debería tener efectos secundarios.
  Quiero hacer una reserva de inmediato que las funciones que estamos considerando no tienen efectos secundarios, pero aún pueden tener las funciones que nos llegaron a través de la inyección de dependencia. Entonces, la pureza de las funciones que tenemos con una gran reserva.
• Prueba unitaria
  Una prueba de función que verifica que todas las bifurcaciones dentro de esta función funcionen exactamente como el autor del código pretendía. En este caso, en lugar de llamar a otras funciones, se usa una llamada a moks.

Entendemos en la práctica

Considera un ejemplo. Una fábrica de contadores que cuentan tick . El contador se puede detener utilizando el método de cancel .

 const createCounter = ({ ticks, onTick }) => { const state = { currentTick: 1, timer: null, canceled: false } const cancel = () => { if (state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(state.timer) } const onInterval = () => { onTick(state.currentTick++) if (state.currentTick > ticks) { cancel() } } state.timer = setInterval(onInterval, 200) const instance = { cancel } return instance } export default createCounter 

Vemos un código comprensible y legible para humanos. Pero hay un inconveniente: las pruebas unitarias normales no se pueden escribir en él. ¿Veamos qué hay en el camino?

1) no puede alcanzar las funciones dentro de la cancel , en el onInterval y probarlas por separado.

2) la función onInterval no se puede probar por separado de la función cancel , porque el primero tiene un enlace directo al segundo.

3) clearInterval las dependencias externas setInterval , clearInterval .

4) la función createCounter no se puede probar por separado de otras funciones, nuevamente debido a los enlaces directos.

Solucionemos los problemas 1) 2): eliminamos las onInterval cancel , onInterval del cierre y rompemos los enlaces directos entre ellas a través del objeto pool .

 export const cancel = pool => { if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } const createCounter = config => { const pool = { config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = cancel.bind(null, pool) pool.onInterval = onInterval.bind(null, pool) pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } export default createCounter 

Resolvemos el problema 3). Usamos el patrón de inyección de dependencia en setInterval , clearInterval y también los transferimos al objeto de pool .

 export const cancel = pool => { const { clearInterval } = pool if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } const createCounter = (dependencies, config) => { const pool = { ...dependencies, config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = cancel.bind(null, pool) pool.onInterval = onInterval.bind(null, pool) const { setInterval } = pool pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } export default createCounter.bind(null, { setInterval, clearInterval }) 

Ahora casi todo está bien, pero todavía hay un problema 4). En el último paso, aplicamos la Inyección de dependencias a cada una de nuestras funciones y rompemos las conexiones restantes entre ellas a través del objeto pool . Al mismo tiempo, dividiremos un archivo grande en muchos archivos, para que luego sea más fácil escribir pruebas unitarias.

 // index.js import { createCounter } from './create-counter' import { cancel } from './cancel' import { onInterval } from './on-interval' export default createCounter.bind(null, { cancel, onInterval, setInterval, clearInterval }) 

 // create-counter.js export const createCounter = (dependencies, config) => { const pool = { ...dependencies, config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = dependencies.cancel.bind(null, pool) pool.onInterval = dependencies.onInterval.bind(null, pool) const { setInterval } = pool pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } 

 // on-interval.js export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } 

 // cancel.js export const cancel = pool => { const { clearInterval } = pool if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } 

Conclusión

¿Qué tenemos al final? Un montón de archivos, cada uno de los cuales contiene una función limpia. La simplicidad y la comprensibilidad del código se han deteriorado un poco, pero esto se ve más que compensado por la imagen del 100% de cobertura en las pruebas unitarias.

También quiero señalar que para escribir pruebas unitarias no necesitamos hacer ninguna manipulación con require y obtener el sistema de archivos Node.js.

 // cancel.test.js import { cancel } from '../src/cancel' describe('method "cancel"', () => { test('should stop the counter', () => { const state = { canceled: false, timer: 42 } const clearInterval = jest.fn() const pool = { state, clearInterval } cancel(pool) expect(clearInterval).toHaveBeenCalledWith(pool.state.timer) }) test('should throw error: "Counter" already canceled', () => { const state = { canceled: true, timer: 42 } const clearInterval = jest.fn() const pool = { state, clearInterval } expect(() => cancel(pool)).toThrow('"Counter" already canceled') expect(clearInterval).not.toHaveBeenCalled() }) }) 

 // create-counter.test.js import { createCounter } from '../src/create-counter' describe('method "createCounter"', () => { test('should create a counter', () => { const boundCancel = jest.fn() const boundOnInterval = jest.fn() const timer = 42 const cancel = { bind: jest.fn().mockReturnValue(boundCancel) } const onInterval = { bind: jest.fn().mockReturnValue(boundOnInterval) } const setInterval = jest.fn().mockReturnValue(timer) const dependencies = { cancel, onInterval, setInterval } const config = { ticks: 42 } const counter = createCounter(dependencies, config) expect(cancel.bind).toHaveBeenCalled() expect(onInterval.bind).toHaveBeenCalled() expect(setInterval).toHaveBeenCalledWith(boundOnInterval, 200) expect(counter).toHaveProperty('cancel') }) }) 

 // on-interval.test.js import { onInterval } from '../src/on-interval' describe('method "onInterval"', () => { test('should call "onTick"', () => { const onTick = jest.fn() const cancel = jest.fn() const state = { currentTick: 1 } const config = { ticks: 5, onTick } const pool = { onTick, cancel, state, config } onInterval(pool) expect(onTick).toHaveBeenCalledWith(1) expect(pool.state.currentTick).toEqual(2) expect(cancel).not.toHaveBeenCalled() }) test('should call "onTick" and "cancel"', () => { const onTick = jest.fn() const cancel = jest.fn() const state = { currentTick: 5 } const config = { ticks: 5, onTick } const pool = { onTick, cancel, state, config } onInterval(pool) expect(onTick).toHaveBeenCalledWith(5) expect(pool.state.currentTick).toEqual(6) expect(cancel).toHaveBeenCalledWith() }) }) 

Solo al abrir todas las funciones hasta el final, ganamos libertad.