¡Hola compañeros programadores! En este octubre dorado, el Día Nacional se superpone con el Festival del Medio Otoño, y tenemos una tarea especial: encontrar el misterioso "Pastel del Medio Otoño" del código a través de las pruebas unitarias de Jest. Es una aventura sencilla y divertida, tan fácil como buscar la luna en una fiesta del Festival del Medio Otoño. ¡Excavemos juntos los tesoros del código y le enviemos dobles bendiciones en el Día Nacional y el Festival del Medio Otoño!
Es
¿Qué es la broma?
Jest es un popular marco de prueba de JavaScript centrado en simplificar y mejorar el proceso de prueba de código. Está desarrollado y mantenido por Facebook y tiene las siguientes características:
1. Facilidad de uso: Jest proporciona un marco de prueba simple y potente que facilita la escritura y ejecución de pruebas.
2. Automatización: descubre y ejecuta pruebas automáticamente sin una configuración compleja, y puede comenzar a probar su código de inmediato.
3. Biblioteca de aserciones: Jest integra una poderosa biblioteca de aserciones para verificar el comportamiento esperado del código y ayudarlo a detectar posibles problemas.
4. Simulación y funciones simuladas: Jest admite entornos de prueba simulados, lo que facilita la simulación de funciones y módulos, mejorando así la eficiencia de las pruebas.
5. Pruebas de instantáneas: Jest le permite crear y mantener fácilmente pruebas de instantáneas para garantizar que la representación y la estructura de los componentes de la interfaz de usuario no cambien inesperadamente.
6. Pruebas concurrentes: puede ejecutar pruebas en paralelo, mejorando la velocidad de las pruebas y es especialmente adecuada para bases de código grandes.
7. Ecosistema de complementos enriquecido: hay muchos complementos y extensiones en el ecosistema de Jest para satisfacer diversas necesidades de prueba.
¿Por qué elegir Jest?
Jest es popular entre la comunidad de desarrolladores porque tiene todo lo que necesita para las pruebas de JavaScript de front-end y back-end y es muy fácil comenzar con él. No sólo se utiliza para pruebas unitarias sino también para pruebas de integración y pruebas de un extremo a otro. Las funciones de automatización y la potente funcionalidad de Jest hacen que las pruebas sean más fáciles y eficientes, lo que ayuda a mejorar la calidad del código y reducir posibles problemas. Ya sea que sea un desarrollador front-end o back-end, Jest es una herramienta de prueba que vale la pena considerar.
Introducción
Jest es un marco de prueba basado en Jasmine y Mocha que proporciona una API fácil de usar para escribir casos de prueba concisos y fáciles de mantener. Jest también integra bibliotecas de aserciones, herramientas de funciones simuladas e informes de cobertura de código.
Instalar
Primero, asegúrese de haber inicializado npm en el directorio del proyecto. Luego, instale Jest usando el siguiente comando:
npm install --save-dev jest
Una vez completada la instalación, puede agregar un comando en la sección "scripts" de package.json para ejecutar pruebas de manera más conveniente:
"scripts": {
"test": "jest"
}
A continuación podemos empezar felizmente a escribir casos de prueba.
Escribir casos de prueba
Primero cree un archivo llamado sum.js que contenga las siguientes funciones:
// sum.js
function sum(a, b) {
return a + b;
}
module.exports = sum;
Ahora, cree un archivo llamado sum.test.js para escribir casos de prueba para la función de suma:
// sum.test.js
const sum = require('./sum');
test('adds 1 + 2 to equal 3', () => {
expect(sum(1, 2)).toBe(3);
});
En este caso de prueba, utilizamos la función global de prueba para definir una prueba. Entre ellos, el primer parámetro es la descripción de la prueba y el segundo parámetro es una función en la que escribimos la lógica de la prueba. Utilice la función expect para hacer valer los resultados de nuestras pruebas.
Ejecutar pruebas
Ahora puedes ejecutar la prueba. Ejecute el siguiente comando en la terminal:
npm test
afirmación
Jest proporciona métodos de afirmación completos para verificar los resultados esperados. A continuación se muestran algunos métodos de aserción de uso común:
expect(value).toBe(expected): comprueba si el valor es igual al esperado.
expect(value).toEqual(expected): comprueba si el valor es igual al esperado.
expect(value).toBeNull(): comprueba si el valor es nulo.
expect(value).toBeDefined(): comprueba si el valor está definido.
expect(value).toBeTruthy(): comprueba si el valor es verdadero.
expect(value).toBeFalsy(): comprueba si el valor es falso.
expect(value).not.toBe(expected): comprueba si el valor no es igual al esperado.
Pruebas asincrónicas
Cuando se trata de lógica asincrónica, Jest proporciona múltiples formas de escribir y manejar pruebas asincrónicas.
Hay dos métodos comúnmente utilizados:
Utilice palabras clave asíncronas y en espera:
test('async test', async () => {
const data = await fetchData();
expect(data).toEqual(expectedData);
});
Utilice el parámetro hecho:
test('callback test', (done) => {
fetchData((data) => {
expect(data).toEqual(expectedData);
done();
});
});
Burlón
Al realizar pruebas, a menudo necesitamos simular el comportamiento de una función o módulo. Jest proporciona herramientas de funciones simuladas integradas para lograr esta funcionalidad.
Aquí hay un ejemplo que utiliza la función simulada de Jest:
function fetchData(callback) {
// 假设这是一个异步操作
setTimeout(() => {
callback('Hello Jest!');
}, 1000);
}
test('mocking test', () => {
const mockCallback = jest.fn();
fetchData(mockCallback);
expect(mockCallback).toHaveBeenCalledTimes(1);
expect(mockCallback).toHaveBeenCalledWith('Hello Jest!');
});
En el ejemplo anterior, creamos una función simulada mockCallback usando jest.fn() y luego la pasamos como una función de devolución de llamada a la función fetchData. Al usar jest.fn(), podemos rastrear la cantidad de llamadas a esta función simulada y los parámetros pasados para las afirmaciones.
cobertura de código
La cobertura del código es una medida de la cobertura de la prueba. Jest proporciona herramientas de cobertura de código integradas que pueden ayudarle a analizar la cobertura de las pruebas.
Los informes de cobertura de código se pueden generar agregando la siguiente configuración en package.json:
"scripts": {
"test": "jest --coverage"
}
Después de ejecutar el comando npm test, Jest generará un informe de cobertura de código que muestra la cobertura de su prueba.
Configuración avanzada
Jest proporciona una gran cantidad de opciones de configuración para satisfacer las necesidades del proyecto. Puede crear un archivo jest.config.js en el directorio raíz del proyecto para configurar Jest.
Aquí hay un ejemplo de configuración simple:
// jest.config.js
module.exports = {
verbose: true,
testEnvironment: 'node',
coverageDirectory: 'coverage',
collectCoverageFrom: ['src/**/*.js'],
};
Pruebas de excepción
En el código de prueba, debemos asegurarnos de que las excepciones se manejen correctamente. Jest proporciona múltiples métodos de aserción para manejar excepciones.
function divide(a, b) {
if (b === 0) {
throw new Error('Divide by zero');
}
return a / b;
}
test('divide should throw an error when dividing by zero', () => {
expect(() => {
divide(10, 0);
}).toThrow('Divide by zero');
});
En el ejemplo anterior, utilizamos el método de aserción toThrow para verificar que el código arroje el error esperado.
Prueba de código asincrónico en busca de errores
Al probar código asincrónico, debe asegurarse de detectar errores en operaciones asincrónicas. Jest ofrece varias formas de manejar esta situación.
async function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
reject('Fetch error');
}, 1000);
});
}
test('fetchData should throw an error', async () => {
expect.assertions(1);
try {
await fetchData();
} catch (error) {
expect(error).toEqual('Fetch error');
}
});
En el ejemplo anterior, utilizamos expect.assertions para garantizar que se ejecute al menos una aserción. Luego use un bloque try-catch para detectar el error en la función fetchData y use una aserción para verificar el valor del error.
El número de llamadas a métodos en el objeto de prueba.
A veces necesitamos asegurarnos de que el método de un objeto se llame correctamente una cantidad específica de veces. Jest proporciona métodos para verificar la cantidad de llamadas a una función simulada.
class Counter {
constructor() {
this.count = 0;
}
increment() {
this.count++;
}
}
test('Counter increment method should be called twice', () => {
const counter = new Counter();
counter.increment();
counter.increment();
const incrementMock = jest.spyOn(counter, 'increment');
expect(incrementMock).toHaveBeenCalledTimes(2);
});
En el ejemplo anterior, usamos jest.spyOn para monitorear el método de incremento de la clase Counter y luego verificamos que el método se haya llamado correctamente dos veces llamando al método de incremento dos veces y usando el método de aserción toHaveBeenCalledTimes.
Interacciones de los componentes de prueba
Al probar componentes de React, a menudo necesitamos simular la interacción del usuario y verificar el comportamiento del componente. Jest proporciona algunos métodos y herramientas para ayudar a probar los componentes de React.
import {
render, fireEvent } from '@testing-library/react';
import Button from './Button';
test('Button click should trigger callback', () => {
const handleClick = jest.fn();
const {
getByText } = render(<Button onClick={
handleClick}>Click me</Button>);
const button = getByText('Click me');
fireEvent.click(button);
expect(handleClick).toHaveBeenCalled();
});
En el ejemplo anterior, utilizamos la función render y la herramienta fireEvent de la biblioteca @testing-library/react para renderizar y probar el componente. Luego use jest.fn para crear una función simulada para monitorear la función de devolución de llamada y activar la devolución de llamada simulando un clic en un botón, y use el método de aserción toHaveBeenCalled para verificar si se llama a la función de devolución de llamada.
Prueba de instantánea
La prueba de instantáneas es un método de prueba que se utiliza para capturar la representación inicial y el estado de un componente o estructura de datos. El método toMatchSnapshot de Jest se puede utilizar para crear y comparar instantáneas.
import renderer from 'react-test-renderer';
import MyComponent from './MyComponent';
test('MyComponent snapshot', () => {
const tree = renderer.create(<MyComponent />).toJSON();
expect(tree).toMatchSnapshot();
});
La primera vez que ejecuta una prueba, Jest creará un archivo de instantánea y luego comparará la instantánea con los nuevos resultados de renderizado en ejecuciones posteriores. Esto ayuda a detectar si un componente ha cambiado inesperadamente.
Pruebas paramétricas
A veces necesitamos probar un conjunto de entradas similares y podemos usar pruebas parametrizadas para reducir la duplicación de código.
const testData = [
{
input: 2, expected: 4 },
{
input: 3, expected: 9 },
{
input: 4, expected: 16 },
];
test.each(testData)('square(%i) should return %i', (input, expected) => {
expect(square(input)).toBe(expected);
});
En el ejemplo anterior, utilizamos el método test.each para definir una prueba parametrizada que ejecutará el mismo código de prueba varias veces en función de diferentes valores de entrada, evitando así casos de prueba duplicados.
comparador personalizado
Jest le permite crear comparadores personalizados para que sea más fácil escribir aserciones específicas de la aplicación.
expect.extend({
toBeValidEmail(received) {
const regex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{
2,}$/i;
const pass = regex.test(received);
if (pass) {
return {
message: () => `expected ${
received} not to be a valid email`,
pass: true,
};
} else {
return {
message: () => `expected ${
received} to be a valid email`,
pass: false,
};
}
},
});
test('email validation', () => {
expect('[email protected]').toBeValidEmail();
expect('invalid-email').not.toBeValidEmail();
});
En el ejemplo anterior, creamos un comparador personalizado para BeValidEmail que verifica que una cadena sea una dirección de correo electrónico válida. Esto nos permite utilizar aserciones personalizadas para verificar el comportamiento específico de la aplicación.
Usar antes de cada y después de cada
Las funciones beforeEach y afterEach le permiten realizar acciones específicas antes y después de cada caso de prueba, como configurar y limpiar el entorno de prueba.
let counter = 0;
beforeEach(() => {
counter++;
});
afterEach(() => {
counter = 0;
});
test('increment counter', () => {
expect(counter).toBe(1);
});
test('reset counter', () => {
expect(counter).toBe(1);
counter = 5;
expect(counter).toBe(5);
});
En el ejemplo anterior, beforeEach se usa para incrementar el contador antes de cada caso de prueba, mientras que afterEach se usa para restablecer el contador a 0 después de cada caso de prueba para garantizar el aislamiento de las pruebas.
Métodos del ciclo de vida de los componentes de prueba
Si usa React u otra biblioteca que admita métodos de ciclo de vida, puede usar jest y enzima (u otras bibliotecas) para probar los métodos de ciclo de vida de su componente.
import React from 'react';
import {
mount } from 'enzyme';
import MyComponent from './MyComponent';
test('componentDidMount is called', () => {
const componentDidMountSpy = jest.spyOn(MyComponent.prototype, 'componentDidMount');
const wrapper = mount(<MyComponent />);
expect(componentDidMountSpy).toHaveBeenCalled();
componentDidMountSpy.mockRestore();
});
En el ejemplo anterior, usamos enzima para montar un componente de React y jest.spyOn para monitorear las llamadas al método de ciclo de vida componenteDidMount.
tiempo de simulación
A veces es necesario probar operaciones relacionadas con el tiempo, como setTimeout o setInterval. Jest proporciona una forma de simular el tiempo.
jest.useFakeTimers();
test('setTimeout test', () => {
const callback = jest.fn();
setTimeout(callback, 1000);
jest.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalled();
});
En este ejemplo, usamos jest.useFakeTimers() para simular el tiempo y jest.advanceTimersByTime para avanzar el tiempo y activar la función de devolución de llamada setTimeout.
Finalmente: se ha compilado y subido el video tutorial completo de prueba de software a continuación. Los amigos que lo necesiten pueden obtenerlo ellos mismos.【保证100%免费】
Documento de entrevista de prueba de software
Debemos estudiar para encontrar un trabajo bien remunerado. Las siguientes preguntas de la entrevista provienen de los últimos materiales de entrevista de empresas de Internet de primer nivel como Alibaba, Tencent, Byte, etc., y algunos jefes de Byte han dado respuestas autorizadas. Después de terminar esto set Creo que todos pueden encontrar un trabajo satisfactorio según la información de la entrevista.
