Jest est une bibliothèque pour tester le code JavaScript.
Il s'agit d'un projet open source maintenu par Facebook, et il est particulièrement bien adapté aux tests de code React, sans toutefois s'y limiter : il peut tester n'importe quel code JavaScript. Ses atouts sont :
export default function sum(a, n) {
return a + b;
}
divide.test.js
import sum from './sum';
// Describe the test and wrap it in a function.
it('adds 1 + 2 to equal 3', () => {
const result = sum(1, 2);
// Jest uses matchers, like pretty much any other JavaScript testing framework.
// They're designed to be easy to get at a glance;
// here, you're expecting `result` to be 3.
expect(result).toBe(3);
});
Un matcher est une méthode qui vous permet de tester des valeurs.
Une dépendance est un morceau de code dont dépend votre application. Il peut s'agir d'une fonction/Objet dans notre projet ou d'une dépendance tierce (ex axios)
Un morceau de code devient une véritable dépendance lorsque votre propre application ne peut pas fonctionner sans lui.
Par exemple, si vous implémentez une fonctionnalité dans votre application pour envoyer des e-mails, faire des requêtes API ou créer un objet de configuration, etc.
Il existe deux façons d'ajouter des dépendances dans notre code dans un projet js :
export default function sum(a, n) {
return a + b;
}
Juste un terme sophistiqué sur un concept simple.
Si votre fonction a besoin de certaines fonctionnalités d'une dépendance externe, injectez-la simplement comme argument.
import sum from './sum';
// Describe the test and wrap it in a function.
it('adds 1 + 2 to equal 3', () => {
const result = sum(1, 2);
// Jest uses matchers, like pretty much any other JavaScript testing framework.
// They're designed to be easy to get at a glance;
// here, you're expecting `result` to be 3.
expect(result).toBe(3);
});
Les tests unitaires sont écrits et exécutés par des développeurs de logiciels pour garantir qu'une section d'une application (appelée « unité ») répond à sa conception et se comporte comme prévu.
Nous voulons tester notre code de manière isolée, nous ne nous soucions pas de la mise en œuvre réelle des dépendances.
Nous voulons vérifier
Et c'est là que se moquer de nos dépendances entre en jeu.
Dans les tests unitaires, les simulations nous offrent la capacité de supprimer la fonctionnalité fournie par une dépendance et un moyen d'observer comment notre code interagit avec la dépendance.
Les simulations sont particulièrement utiles lorsqu'il est coûteux ou peu pratique d'inclure une dépendance directement dans nos tests, par exemple, dans les cas où votre code effectue des appels HTTP à une API ou interagit avec la couche de base de données.
Il est préférable d'effacer les réponses de ces dépendances, tout en s'assurant qu'elles sont appelées selon les besoins. C'est là que les moqueries sont utiles.
En utilisant des fonctions fictives, nous pouvons connaître les éléments suivants :
Il existe plusieurs façons de créer des fonctions fictives.
La méthode jest.fn est, en elle-même, une fonction d'ordre supérieur.
C'est une méthode d'usine qui crée de nouvelles fonctions fictives inutilisées.
Les fonctions en JavaScript sont des citoyens de premier ordre, elles peuvent être transmises comme arguments.
Chaque fonction fictive a des propriétés spéciales. La propriété mock est fondamentale. Cette propriété est un objet qui contient toutes les informations d'état fictif sur la façon dont la fonction a été invoquée. Cet objet contient trois propriétés de tableau :
export default function sum(a, n) {
return a + b;
}
import sum from './sum';
// Describe the test and wrap it in a function.
it('adds 1 + 2 to equal 3', () => {
const result = sum(1, 2);
// Jest uses matchers, like pretty much any other JavaScript testing framework.
// They're designed to be easy to get at a glance;
// here, you're expecting `result` to be 3.
expect(result).toBe(3);
});
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';
// Constructor Injection
// DatabaseManager class takes a database connector as a dependency
class DatabaseManager {
constructor(databaseConnector) {
// Dependency injection of the database connector
this.databaseConnector = databaseConnector;
}
updateRow(rowId, data) {
// Use the injected database connector to perform the update
this.databaseConnector.update(rowId, data);
}
}
// parameter injection, takes a database connector instance in as an argument; easy to test!
function updateRow(rowId, data, databaseConnector) {
databaseConnector.update(rowId, data);
}
Ce type de moquerie est moins courant pour plusieurs raisons :
Une approche plus courante consiste à utiliser jest.mock pour définir automatiquement toutes les exportations d'un module vers la fonction Mock.
// 1. The mock function factory
function fn(impl = () => {}) {
// 2. The mock function
const mockFn = function(...args) {
// 4. Store the arguments used
mockFn.mock.calls.push(args);
mockFn.mock.instances.push(this);
try {
const value = impl.apply(this, args); // call impl, passing the right this
mockFn.mock.results.push({ type: 'return', value });
return value; // return the value
} catch (value) {
mockFn.mock.results.push({ type: 'throw', value });
throw value; // re-throw the error
}
}
// 3. Mock state
mockFn.mock = { calls: [], instances: [], results: [] };
return mockFn;
}
Parfois, vous souhaitez uniquement voir une méthode être appelée, mais conserver l'implémentation d'origine. D'autres fois, vous souhaiterez peut-être vous moquer de l'implémentation, mais restaurer l'original plus tard dans la suite.
test("returns undefined by default", () => {
const mock = jest.fn();
let result = mock("foo");
expect(result).toBeUndefined();
expect(mock).toHaveBeenCalled();
expect(mock).toHaveBeenCalledTimes(1);
expect(mock).toHaveBeenCalledWith("foo");
});
Restaurer l'implémentation d'origine
const doAdd = (a, b, callback) => {
callback(a + b);
};
test("calls callback with arguments added", () => {
const mockCallback = jest.fn();
doAdd(1, 2, mockCallback);
expect(mockCallback).toHaveBeenCalledWith(3);
});
JavaScript est monothread : une seule tâche peut s'exécuter à la fois. Habituellement, ce n'est pas grave, mais imaginez maintenant que vous exécutez une tâche qui prend 30 secondes. Oui. Pendant cette tâche, nous attendons 30 secondes avant que quoi que ce soit d'autre puisse se produire (JavaScript s'exécute par défaut sur le thread principal du navigateur, donc toute l'interface utilisateur est bloquée).
Nous sommes en 2020, personne ne veut d’un site Web lent et qui ne répond pas.
Heureusement, le navigateur nous offre certaines fonctionnalités que le moteur JavaScript lui-même ne propose pas : une API Web. Cela inclut l'API DOM, setTimeout, les requêtes HTTP, etc. Cela peut nous aider à créer des async, comportements non bloquants
export default function sum(a, n) {
return a + b;
}
import sum from './sum';
// Describe the test and wrap it in a function.
it('adds 1 + 2 to equal 3', () => {
const result = sum(1, 2);
// Jest uses matchers, like pretty much any other JavaScript testing framework.
// They're designed to be easy to get at a glance;
// here, you're expecting `result` to be 3.
expect(result).toBe(3);
});
Jest s'attend généralement à exécuter les fonctions des tests de manière synchrone.
Si nous effectuons une opération asynchrone, mais que nous ne faisons pas savoir à Jest qu'il doit attendre la fin du test, cela donnera un faux positif.
import { name, draw, reportArea, reportPerimeter } from './modules/square.js';
Modèles asynchrones
Il existe plusieurs modèles pour gérer les opérations asynchrones en JavaScript ; les plus utilisés sont :
Vous ne pouvez pas avoir de test dans un rappel, car Jest ne l'exécutera pas - l'exécution du fichier de test se termine avant que le rappel ne soit appelé. Pour résoudre ce problème, transmettez un paramètre à la fonction de test, que vous pouvez facilement appeler terminé. Jest attendra que vous appeliez done() avant de terminer ce test :
// Constructor Injection
// DatabaseManager class takes a database connector as a dependency
class DatabaseManager {
constructor(databaseConnector) {
// Dependency injection of the database connector
this.databaseConnector = databaseConnector;
}
updateRow(rowId, data) {
// Use the injected database connector to perform the update
this.databaseConnector.update(rowId, data);
}
}
// parameter injection, takes a database connector instance in as an argument; easy to test!
function updateRow(rowId, data, databaseConnector) {
databaseConnector.update(rowId, data);
}
Avec les fonctions qui renvoient des promesses, nous renvoyons une promesse du test :
// 1. The mock function factory
function fn(impl = () => {}) {
// 2. The mock function
const mockFn = function(...args) {
// 4. Store the arguments used
mockFn.mock.calls.push(args);
mockFn.mock.instances.push(this);
try {
const value = impl.apply(this, args); // call impl, passing the right this
mockFn.mock.results.push({ type: 'return', value });
return value; // return the value
} catch (value) {
mockFn.mock.results.push({ type: 'throw', value });
throw value; // re-throw the error
}
}
// 3. Mock state
mockFn.mock = { calls: [], instances: [], results: [] };
return mockFn;
}
Pour tester les fonctions qui renvoient des promesses, nous pouvons également utiliser async/await, ce qui rend la syntaxe très simple et directe :
test("returns undefined by default", () => {
const mock = jest.fn();
let result = mock("foo");
expect(result).toBeUndefined();
expect(mock).toHaveBeenCalled();
expect(mock).toHaveBeenCalledTimes(1);
expect(mock).toHaveBeenCalledWith("foo");
});
const doAdd = (a, b, callback) => {
callback(a + b);
};
test("calls callback with arguments added", () => {
const mockCallback = jest.fn();
doAdd(1, 2, mockCallback);
expect(mockCallback).toHaveBeenCalledWith(3);
});
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment copier un tableau Excel pour lui donner la même taille que l'original
Comment utiliser le commutateur Java
Comment lire des fichiers texte en HTML
jquery valider
Utilisation des éléments en python
Comment résoudre l'erreur http 503
Introduction à la relation entre php et front-end
Introduction aux utilisations de la programmation Python
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
