Tutoriel Sinon: tests JavaScript avec des simulations, des espions et des talons

Cet article a été examiné par Mark Brown et Marc Towler. Merci à tous les pair de sitepoint pour avoir obtenu le contenu de sitepoint à son meilleur!

L'un des plus grands obstacles lors de la rédaction de tests unitaires est de savoir comment gérer le code non trivial.

Dans les projets réels, le code effectue souvent diverses opérations qui rendent les tests difficiles. Les demandes AJAX, les minuteries, les dates, l'accès aux autres fonctionnalités du navigateur… ou les bases de données sont toujours amusantes si vous utilisez Node.js, il en va de même pour l'accès au réseau ou au fichier.

Tout cela est difficile à tester car vous ne pouvez pas les contrôler dans votre code. Si vous utilisez Ajax, vous avez besoin d'un serveur pour répondre à la demande afin que vos tests puissent passer. Si vous utilisez Settimeout, votre test devra attendre. Il en va de même pour une base de données ou un réseau - vous avez besoin d'une base de données avec les données correctes ou un serveur réseau.

La vie réelle n'est pas aussi facile que de nombreux tutoriels de test semblent. Mais savez-vous qu'il y a une solution?

En utilisant Sinon, nous pouvons rendre le test de code non trivial trivial!

Voyons comment cela fonctionne.

points clés

• Sinon Test simplifié: sinon.js est essentiel pour simplifier les tests du code JavaScript impliquant des opérations complexes telles que les appels Ajax, les minuteries et les interactions de base de données, car il permet à ces parties d'être remplacées par des maquettes, des espions et des talons.
• Trois types de stand-ins de test: Sinon classe les stand-ins de test comme des informations sur les appels de fonction); objets entiers).
• Cas pratiques: Sinon est particulièrement utile dans les scénarios de test unitaires où les dépendances externes peuvent compliquer ou ralentir les tests, tels que les appels d'API externes ou les fonctions basées sur le temps.
• Intégration et configuration: Sinon peut être facilement intégrée dans les environnements de test Node.js et basés sur le navigateur, améliorant sa polyvalence et sa facilité d'utilisation dans une variété d'applications JavaScript.
• Affirmation améliorée: Sinon fournit des méthodes d'assistance améliorées qui génèrent des messages d'erreur plus clairs, améliorant le processus de débogage lors des défaillances des tests.
• Best Practice: Utiliser sinon.test() Les cas de test d'emballage garantissent que le stand-in de test est correctement nettoyé, empêche les effets secondaires dans d'autres tests et réduit les erreurs potentielles dans la suite de tests.

Qu'est-ce qui rend Sinon si important et utile?

En bref, Sinon vous permet de remplacer la partie difficile des tests par celui qui facilite les tests.

Lors du test d'un morceau de code, vous ne voulez pas qu'il soit affecté par des facteurs à l'extérieur du test. Si certains facteurs externes affectent le test, le test devient plus complexe et peut échouer au hasard.

Comment faites-vous si vous souhaitez tester le code qui fait des appels AJAX? Vous devez exécuter un serveur et vous assurer qu'il fournit la réponse exacte dont vous avez besoin pour vos tests. La configuration est compliquée et rend difficile l'écriture et l'exécution des tests unitaires.

Et si votre code dépend du temps? Supposons qu'il attend une seconde avant d'effectuer une action. Que faire maintenant? Vous pouvez utiliser Settimeout dans votre test pour attendre une seconde, mais cela ralentira le test. Imaginez si l'intervalle est plus long, par exemple, cinq minutes. Je suppose que vous ne voulez probablement pas attendre cinq minutes à chaque fois que vous effectuez vos tests.

En utilisant Sinon, nous pouvons résoudre ces deux problèmes (et bien d'autres) et éliminer la complexité.

Comment fonctionne Sinon?

Sinon aide à supprimer la complexité des tests en vous permettant de créer facilement le soi-disant Test stand-in .

Comme son nom l'indique, le stand-in de test est un remplacement des extraits de code utilisés dans le test. En regardant en arrière l'exemple Ajax, nous ne configurerons pas le serveur, mais remplacerons plutôt l'appel Ajax par le stand-in de test. Pour l'exemple de temps, nous utiliserons un stand-in de test pour nous permettre de "faire avancer le temps".

Cela peut sembler un peu étrange, mais le concept de base est simple. Parce que JavaScript est très dynamique, nous pouvons prendre n'importe quelle fonction et le remplacer par autre chose. Tester un remplaçant ne fait que faire plus loin cette idée. Avec Sinon, nous pouvons remplacer n'importe quelle fonction JavaScript par un stand-in de test, puis nous pouvons le configurer pour effectuer diverses opérations pour faciliter les tests complexes.

Sinon divise les stand-ins de test en trois types:

• espion, fournissant des informations sur les appels de fonction sans affecter leur comportement
• Stume, comme un espion, mais remplace complètement la fonction. Cela permet de faire en sorte que la fonction de stub fait tout ce que vous aimez - lancer des exceptions, renvoyer des valeurs spécifiques, etc.
• Simulation, en combinant des espions et des talons, il est plus facile de remplacer l'ensemble de l'objet

En outre, Sinon fournit d'autres programmes d'aide, bien que ces programmes d'aide soient en dehors de la portée de cet article:

• fausse minuterie, peut être utilisée pour faire avancer le temps, comme le déclenchement de setTimeout
• Faux XMLHTTPREQUEST ET SERVER, qui peuvent être utilisés pour forger des demandes et des réponses AJAX

Avec ces fonctionnalités, Sinon vous permet de résoudre toutes les difficultés causées par les dépendances externes dans les tests. Si vous apprenez les conseils pour l'utilisation efficace de Sinon, vous n'avez pas besoin d'autres outils.

Installation sinon

Tout d'abord, nous devons installer Sinon.

pour le test Node.js:

1. Utilisez NPM Installer Sinon pour installer Sinon via NPM
2. introduire sinon
dans vos tests en utilisant var sinon = require ('sinon');

pour les tests basés sur le navigateur:

1. Vous pouvez utiliser NPM Installer Sinon pour installer Sinon via NPM, utiliser un CDN ou le télécharger à partir du site Web de Sinon
2. Incluez Sinon.js dans votre page Runner Test.

débutant

Sinon a de nombreuses fonctionnalités, mais beaucoup d'entre elles sont construites sur elle-même. Vous en savez une partie, et vous connaissez déjà la partie suivante. Une fois que vous comprenez les bases et comprenez ce que fait chaque partie différente, cela rend Sinon facile à utiliser.

Nous avons généralement besoin de Sinon lorsque notre code appelle une fonction qui nous cause des problèmes.

Pour Ajax, il peut être $ .get ou xmlhttprequest. Pour le temps, la fonction peut être Settimeout. Pour les bases de données, il pourrait s'agir de mongodb.findone.

Pour faciliter la discussion de cette fonction, je l'appelle la dépendance . La fonction que nous testons dépend du résultat d'une autre fonction. Nous pouvons dire que le modèle d'utilisation de base de Sinon est de remplacer les dépendances problématiques par des stand-ins de test.

Lors du test de AJAX, nous remplaçons XMLHttpRequest par un stand-in de test qui simule les demandes AJAX

• Lors du temps de test, nous remplaçons Settimeout par une fausse minuterie
• Lors du test d'accès à la base de données, nous pouvons remplacer mongodb.findone par un stand-in de test qui renvoie quelques fausses données immédiatement
Voyons comment cela fonctionne dans la pratique.

espion

L'espion est la partie la plus facile de Sinon, et d'autres fonctionnalités y sont construites.

Le but principal des espions est de collecter des informations sur les appels de fonction. Vous pouvez également les utiliser pour aider à vérifier certaines choses, par exemple si une fonction est appelée.

Fonction Sinon.spy renvoie un objet d'espion qui peut être appelé comme une fonction, mais contient également des attributs sur tous les appels qui lui sont lancés. Dans l'exemple ci-dessus, la propriété FirstCall contient des informations sur le premier appel, comme FirstCall.args, qui est la liste des paramètres passés.

<code class="language-javascript">var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']
</code>

Bien que vous puissiez créer des espions anonymes en appelant Sinon.spy sans paramètres, le modèle le plus courant est de remplacer une autre fonction par un espion.

Remplacez une autre fonction par un espion et fonctionne de manière similaire à l'exemple précédent, mais par une différence importante: après avoir fini d'utiliser l'espion, assurez-vous de vous rappeler de restaurer la fonction d'origine, comme indiqué dans la dernière ligne de l'exemple ci-dessus . Sans cela, vos tests peuvent se comporter anormalement.

<code class="language-javascript">var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();
</code>

SPY possède de nombreuses propriétés différentes qui fournissent des informations différentes sur la façon dont elles sont utilisées. La documentation d'espion de Sinon contient une liste complète de toutes les options disponibles.

En pratique, vous ne pouvez pas utiliser souvent des espions. Vous êtes plus susceptible d'avoir besoin d'un talon, mais les espions peuvent être pratiques, comme la vérification qu'un rappel est appelé:

Dans cet exemple, j'utilise Mocha comme Framework et Chai comme bibliothèque Assertion. Si vous souhaitez en savoir plus sur ces deux-là, veuillez vous référer à mon article précédent: Testing unitaire de votre javascript avec Mocha et Chai.

<code class="language-javascript">function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});
</code>

Assertion de Sinon

Avant de passer au talon, prenons un détour rapide et jetons un coup d'œil à l'affirmation de Sinon.

Dans la plupart des cas de test où vous utilisez l'espion (et les talons), vous avez besoin d'un moyen de vérifier les résultats du test.

Nous pouvons utiliser tout type d'affirmation pour vérifier le résultat. Dans l'exemple précédent sur les rappels, nous avons utilisé la fonction Assert de Chai, qui garantit que la valeur est la vraie valeur.

<code class="language-javascript">var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']
</code>

L'inconvénient de le faire est que le message d'erreur sur l'échec n'est pas clair. Vous ne recevrez qu'une invite comme "False n'est pas vrai" ou similaire. Comme vous pouvez l'imaginer, cela n'est pas très utile pour découvrir où se trouve le problème, et vous devez consulter le code source du test pour le comprendre. Pas amusant.

Pour résoudre ce problème, nous pouvons inclure des messages d'erreur personnalisés dans l'affirmation.

<code class="language-javascript">var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();
</code>

Mais pourquoi s'embêter quand nous pouvons utiliser Affirmation de Sinon ?

<code class="language-javascript">function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});
</code>

L'utilisation des affirmations de Sinon comme celle-ci peut fournir immédiatement de meilleurs messages d'erreur. Ceci est utile lorsque vous devez valider des conditions plus complexes telles que les paramètres d'une fonction.

Voici quelques autres affirmations utiles fournies par Sinon:

• sinon.assert.Alledwith peut être utilisé pour vérifier que la fonction a été appelée avec un paramètre spécifique (c'est probablement celui que j'utilise le plus)
• sinon.assert.CallOrder peut vérifier que la fonction est appelée dans un ordre spécifique

Comme les espions, la documentation d'affirmation de Sinon contient toutes les options disponibles. Si vous préférez utiliser Chai, il existe également un plugin Sinon-Chai disponible, qui vous permet d'utiliser des assertions sinon via l'attente de Chai ou devrait interface.

Stub

Les talons sont le stand-in de test préféré car ils sont flexibles et pratiques. Ils ont toutes les fonctions des espions, mais ils sont plus que le rôle des fonctions de surveillance, et le talon le remplace complètement. En d'autres termes, lors de l'utilisation d'espion, la fonction d'origine s'exécute toujours, mais lors de l'utilisation de talons, il ne s'exécute pas.

Cela rend les talons très adaptés à de nombreuses tâches telles que:

• Remplacer Ajax ou d'autres appels externes qui rendent les tests lents et difficiles à écrire
• Déclencher différents chemins de code en fonction de la sortie de la fonction
• Test des exceptions, comme ce qui se passe lorsqu'une exception est lancée?

La façon dont nous pouvons créer des talons est similaire à celle des espions ...

<code class="language-javascript">assert(callback.calledOnce);
</code>

Nous pouvons créer des talons anonymes comme les espions, mais les talons deviennent très utiles lorsque vous remplacez les fonctions existantes par des talons.

Par exemple, si nous avons un code qui utilise la fonction ajax de jQuery, il est difficile de le tester. Le code envoie une demande à tout serveur que nous configurons, nous devons donc le rendre disponible, ou ajouter un cas spécial au code afin qu'il ne le fasse pas dans un environnement de test - c'est un gros tabou. Vous devez à peine inclure des cas spécifiques au test dans votre code.

Au lieu de se tourner vers de mauvaises pratiques, nous pouvons utiliser Sinon et remplacer la fonction Ajax par un talon. Cela rend le test trivial.

Il s'agit d'un exemple de fonction que nous testerons. Il prend l'objet en tant que paramètre et l'envoie à une URL prédéfinie via AJAX.

<code class="language-javascript">var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']
</code>

Habituellement, le test sera difficile en raison des appels AJAX et des URL prédéfinis, mais si nous utilisons des talons, cela deviendra facile.

Supposons que nous voulons nous assurer que la fonction de rappel transmise à SaveUser est appelée correctement une fois la demande terminée.

<code class="language-javascript">var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();
</code>

Ici, nous remplaçons la fonction Ajax par un talon. Cela signifie que la demande n'est jamais envoyée, nous n'avons pas besoin d'un serveur ou quoi que ce soit - nous avons un contrôle complet sur ce qui se passe dans le code de test!

Parce que nous voulons nous assurer que le rappel que nous passons à SaveUser est appelé, nous instruireons le talon rendement . Cela signifie que le talon appellera automatiquement la première fonction qui lui est transmise en tant que paramètre. Cela simule le comportement de $ .Post, qui appelle le rappel une fois la demande terminée.

En plus du talon, nous avons également créé un espion dans ce test. Nous pouvons utiliser des fonctions normales comme des rappels, mais l'utilisation d'espions peut facilement vérifier les résultats du test en utilisant Sinon.Asersert.Allsert Assertion.

Dans la plupart des cas, lorsque vous avez besoin de talons, vous pouvez suivre le même modèle de base:

• Trouvez la fonction en question, telle que $ .post
• Affichez comment cela fonctionne afin que vous puissiez le vous moquer de vos tests
• Créez un stub
• Définissez le talon pour avoir le comportement souhaité dans le test

Les talons n'ont pas besoin de simuler chaque comportement. Le seul comportement requis pour les tests est nécessaire et tout le reste peut être omis.

Une autre utilisation courante de

Stubs consiste à vérifier que les fonctions sont appelées avec un ensemble de paramètres spécifique.

Par exemple, pour notre fonction AJAX, nous voulons nous assurer que la valeur correcte est envoyée. Par conséquent, nous pouvons avoir quelque chose comme les suivants:

<code class="language-javascript">function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});
</code>

De même, nous avons créé un talon pour $ .post (), mais cette fois, nous ne l'avons pas réglé pour céder. Ce test ne se soucie pas des rappels, il n'est donc pas nécessaire de le rendre.

Nous avons configuré certaines variables pour contenir les données attendues: l'URL et les paramètres. La définition de ces variables est une bonne habitude car elle nous permet de voir les exigences du test en un coup d'œil. Il nous aide également à définir des variables utilisateur sans valeurs en double.

Cette fois, nous avons utilisé l'affirmation Sinon.Asersert.CalledWith (). Nous passons le talon comme premier paramètre, car cette fois, nous voulons vérifier que le talon est appelé avec le paramètre correct.

Il existe un autre moyen de tester les demandes AJAX dans Sinon. Cela se fait en utilisant la fausse fonctionnalité XMLHttpRequest de Sinon. Nous n'entrerons pas dans les détails ici, mais si vous voulez comprendre comment cela fonctionne, consultez mon article sur les tests Ajax en utilisant les faux XMLHTTPRequest de Sinon.

simulation

La simulation est une approche différente de celle des talons. Si vous avez entendu parler du terme "objets simulés", c'est la même chose - les simulations de Sinon peuvent être utilisées pour remplacer des objets entiers et modifier leur comportement, similaire aux fonctions Stume.

Si vous avez besoin de coller plusieurs fonctions à partir d'un seul objet, elles sont principalement utiles. Si vous n'avez besoin que de remplacer une seule fonction, le stub est plus facile à utiliser.

Vous devez être prudent lorsque vous utilisez la simulation! En raison de leur pouvoir, il est facile de rendre vos tests trop spécifiques - trop et des choses trop spécifiques - qui peuvent rendre par inadvertance vos tests vulnérables.

Contrairement aux espions et aux talons, les simulations ont des affirmations intégrées. Vous pouvez prédéfinir le résultat attendu en disant à l'objet simulé ce qui doit se produire, puis en appelant la fonction de vérification à la fin du test.

Supposons que nous utilisons Store.js pour enregistrer le contenu sur LocalStorage, et que nous voulons tester les fonctions qui y sont liées. Nous pouvons utiliser la simulation pour aider à le tester comme suit:

<code class="language-javascript">var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']
</code>

Lors de l'utilisation de la simulation, nous utilisons un style d'appel lisse pour définir l'appel attendu et ses résultats, comme indiqué ci-dessus. Ceci est le même que l'utilisation de l'affirmation pour valider les résultats des tests, sauf que nous les avons prédéfinis et pour les vérifier, nous appelons StoreMock.verify () à la fin du test.

Dans le terme d'objet simulé de Sinon, appeler mock.expect ('quelque chose') crée un attendre . C'est-à-dire que la méthode mock.something () devrait être appelée. Chaque attente prend en charge les mêmes fonctions que l'espion et les talons en plus d'émuler des fonctions spécifiques.

Vous pouvez constater que l'utilisation de talons est généralement plus facile que d'utiliser des simulations - c'est tout à fait OK. La simulation doit être utilisée avec prudence.

Pour une liste complète de fonctions spécifiques simulées, consultez la documentation de simulation de Sinon.

Meilleures pratiques importantes: utiliser sinon.test ()

Sinon a une meilleure pratique importante qui devrait être gardée à l'esprit lors de l'utilisation d'espions, de talons ou de simulations.

Si vous remplacez une fonction existante par un stand-in de test, utilisez Sinon.Test ().

Dans l'exemple précédent, nous utilisons Stub.Restore () ou Mock.Restore () pour nettoyer le contenu après les avoir utilisés. Ceci est nécessaire car sinon le remplaçant de test restera en place et peut affecter négativement d'autres tests ou entraîner des erreurs.

mais il est problématique d'utiliser directement la fonction Restore (). La fonction testée peut provoquer une erreur et terminer la fonction de test avant d'appeler Restore ()!

Nous avons deux façons de résoudre ce problème: nous pouvons envelopper l'intégralité du contenu dans un bloc d'essai. Cela nous permet de mettre l'appel Restore () dans le bloc enfin, en nous assurant qu'il fonctionnera quoi qu'il arrive.

ou, une meilleure façon est d'envelopper la fonction de test à l'aide de sinon.test ()

<code class="language-javascript">var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();
</code>

Dans l'exemple ci-dessus, notez que le deuxième paramètre de celui-ci () est enveloppé dans sinon.test (). La deuxième chose à noter est que nous utilisons ce.stub () au lieu de Sinon.Stub ().

Utiliser le test d'enveloppe Sinon.test () nous permet d'utiliser la fonction Sinon

sandbox , nous permettant de créer des espions et des talons via ce.spy (), this.stub () et this.mock () et simulation. Tout stand-in de test créé à l'aide du bac à sable sera automatiquement nettoyé.

Notez que notre exemple de code ci-dessus n'a pas Stub.Restore () - il n'est pas nécessaire car le test est sableux.

Si vous utilisez Sinon.Test () dans la mesure du possible, vous pouvez éviter le problème que le test commence à échouer au hasard en raison d'un test précoce sans nettoyer son test autonome en raison d'erreurs.

sinon n'est pas une magie

Sinon effectue de nombreuses opérations et peut parfois être difficile à comprendre comment cela fonctionne. Jetons un coup d'œil à quelques exemples JavaScript simples du fonctionnement de Sinon afin que nous puissions mieux comprendre comment cela fonctionne en interne. Cela vous aidera à l'utiliser plus efficacement dans différentes situations.

Nous pouvons également créer des espions, des talons et des simulations manuellement. La raison pour laquelle nous utilisons Sinon est que cela rend les tâches triviales - les créer manuellement peut être très complexe, mais voyons comment cela fonctionne pour comprendre ce que fait Sinon.

Tout d'abord, l'espion est essentiellement un wrapper de fonction:

<code class="language-javascript">var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']
</code>

Nous pouvons facilement obtenir des fonctionnalités d'espionnage en utilisant des fonctions personnalisées. Mais notez que les espions de Sinon offrent un plus large éventail de fonctionnalités, y compris le support d'assertion. Cela rend Sinon plus pratique.

qu'en est-il du talon?

Pour créer un stub très simple, vous pouvez simplement remplacer une fonction par une nouvelle fonction:

<code class="language-javascript">var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();
</code>

Cependant, les talons de Sinon offrent plusieurs avantages:

• Ils contiennent des fonctionnalités d'espion complètes
• Vous pouvez facilement restaurer le comportement d'origine à l'aide de Stub.Restore ()
• Vous pouvez affirmer contre Sinon Stubs

Les simulations combinent simplement le comportement des espions et des talons, afin que leur fonctionnalité puisse être utilisée de différentes manières.

Même si Sinon semble parfois faire beaucoup de "magie", dans la plupart des cas, cela peut être facilement fait avec votre propre code. Sinon est beaucoup plus pratique à utiliser, plutôt que d'avoir à écrire sa propre bibliothèque à cette fin.

Conclusion

Tester le code réel semble parfois trop compliqué et peut facilement abandonner complètement. Mais avec Sinon, tester presque tous les types de code devient un jeu d'enfant.

N'oubliez pas le principe principal: si la fonction rend votre test difficile à écrire, essayez de le remplacer par un stand-in de test. Ce principe s'applique, peu importe ce que la fonction fonctionne.

Vous voulez savoir comment appliquer Sinon dans votre propre code? Visitez mon site Web et je vous enverrai mon Guide GRATUIT du Sinon World Real qui comprend trois exemples du monde réel de meilleures pratiques de Sinon et comment l'appliquer dans différents types de situations de test!

FAQ sur Sinon.js Test (FAQ)

Quelle est la différence entre les simulations, les espions et les talons dans sinon.js?

dans sinon.js, les simulations, les espions et les talons ont des utilisations différentes. Un espion est une fonction qui enregistre tous les paramètres appelés, les valeurs de retour, la valeur de cela et l'exception lancée (le cas échéant). Ils peuvent être utilisés pour suivre les appels et les réponses de la fonction. Le talon est similaire à un espion, mais a un comportement préprogrammé. Ils enregistrent également des informations sur la façon dont ils sont appelés, mais contrairement aux espions, ils peuvent être utilisés pour contrôler le comportement des méthodes pour forcer les méthodes à lancer des erreurs ou à renvoyer des valeurs spécifiques. La simulation est une fausse méthode avec un comportement pré-programmé (tel que des talons) ainsi que des attentes préprogrammées (comme l'espion).

Comment utiliser Sinon.js pour les tests unitaires en JavaScript?

sinon.js est un outil puissant pour créer des espions, des talons et des simulations dans les tests JavaScript. Pour l'utiliser, vous devez d'abord l'inclure dans votre projet en utilisant des balises de script dans votre HTML ou en l'installant via NPM. Une fois inclus, vous pouvez utiliser son API pour créer et gérer les espions, les talons et les simulations. Ceux-ci peuvent ensuite être utilisés pour isoler le code que vous testez et s'assurer qu'il fonctionne comme prévu.

Comment créer un espion dans sinon.js?

Créer un espion dans sinon.js est simple. Il vous suffit d'appeler la fonction sinon.spy (). Cela renverra une fonction d'espionnage que vous pouvez utiliser dans vos tests. L'espion enregistrera des informations sur la façon de l'appeler, que vous pouvez ensuite vérifier vos tests. Par exemple, vous pouvez vérifier combien de fois un espion est appelé, quels paramètres sont utilisés pour l'appeler et ce qu'il retourne.

Comment créer des talons dans sinon.js?

Pour créer un stub dans sinon.js, vous devez appeler la fonction sinon.stub (). Cela renverra une fonction de talon que vous pouvez utiliser dans vos tests. Le talon se comporte comme un espion, enregistrant des informations sur la façon de l'appeler, mais il vous permet également de contrôler son comportement. Par exemple, vous pouvez faire en sorte que le stub lance une erreur ou renvoyer une valeur spécifique.

Comment créer une maquette dans sinon.js?

Créer une simulation dans Sinon.js implique d'appeler la fonction sinon.mock (). Cela renverra un objet simulé que vous pouvez utiliser dans vos tests. L'objet simulé se comporte comme un espion, enregistre des informations sur la façon de l'appeler, et est similaire à un talon, vous permettant de contrôler son comportement. Mais cela vous permet également de définir des attentes sur la façon de l'appeler.

Comment utiliser Sinon.js avec d'autres cadres de test?

sinon.js est conçu pour être utilisé avec n'importe quel cadre de test JavaScript. Il fournit un cadre de test autonome, mais il peut également être intégré à d'autres cadres de test populaires tels que Mocha, Jasmine et Qunit. La documentation Sinon.js fournit des exemples d'intégration avec ces cadres de test et d'autres.

Comment restaurer un talon ou un espion à sa fonction d'origine?

Si vous avez remplacé la fonction par un talon ou un espion, vous pouvez restaurer la fonction d'origine en appelant la méthode .Restore () sur le talon ou l'espion. Ceci est utile si vous souhaitez nettoyer après les tests pour vous assurer que le talon ou l'espion n'affecte pas d'autres tests.

Comment vérifier si l'espion a été appelé avec des paramètres spécifiques?

sinon.js fournit plusieurs façons de vérifier comment appeler un espion. Par exemple, vous pouvez utiliser la méthode .CalledWith () pour vérifier si un espion a été appelé avec un paramètre spécifique. Vous pouvez également utiliser la méthode .CalleDonceWith () pour vérifier si l'espion n'était appelé qu'une seule fois avec un paramètre spécifique.

Comment faire un talon renvoie une valeur spécifique?

Vous pouvez utiliser la méthode .Returns () pour faire renvoyer le talon une valeur spécifique. Par exemple, si vous avez un talon nommé MyStub, vous pouvez renvoyer la valeur «foo» en appelant mystub.returns («foo»).

Comment faire un stub lance une erreur?

Vous pouvez utiliser la méthode .throws () pour faire en sorte que le stub lance une erreur. Par exemple, si vous avez un talon nommé MyStub, vous pouvez le faire lancer une erreur en appelant mystub.throws (). Par défaut, cela lancera un objet d'erreur, mais vous pouvez également faire en sorte que l'erreur lance un type d'erreur spécifique en passant le nom de l'erreur en tant que paramètre.

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!