Affiche de l'outil de test JavaScript: sinon.js vs testdouble.js

Lorsque un unité teste le code du monde réel, de nombreuses situations rendent le test difficile à écrire. Comment vérifier si une fonction est appelée? Comment tester les appels AJAX? Ou utiliser le code de setTimeout? À l'heure actuelle, vous devez utiliser pour tester le stand-in - remplacer le code pour faciliter le test dans le mal à tester.

Depuis de nombreuses années, Sinon.js est la norme réelle pour créer des stand-ins de test dans les tests JavaScript. C'est un outil essentiel pour tout développeur JavaScript qui écrit des tests, car sans lui, il est presque impossible d'écrire des tests pour de vraies applications.

Récemment, une nouvelle bibliothèque appelée TestDouble.js émerge. Il a une fonctionnalité similaire sur Sinon.js, sauf qu'il existe quelques différences ici et là.

Dans cet article, nous explorerons ce que Sinon.js et TestDouble.js fournissent et comparent leurs avantages et inconvénients respectifs. Sinon.js est-il toujours un meilleur choix, ou le Challenger peut-il gagner?

Remarque: Si vous n'êtes pas familier avec le test des stand-ins, il est recommandé de lire d'abord mon didacticiel sinon.js. Cela vous aidera à mieux comprendre les concepts dont nous discuterons ici.

points clés

• Ensembles de fonctionnalités et terminologie: Sinon.js fournit un ensemble traditionnel de stand-ins de test, y compris les espions, les talons et les simulations, qui sont familiers à ceux qui sont compétents dans d'autres langages de programmation, tandis que TestDouble.js simplifie la terminologie et se concentre En termes de vocabulaire centré sur JavaScript, les espions traditionnels sont éliminés.
• Facile à utiliser: TestDouble.js a une API plus simple qui est plus facile à maîtriser pour les débutants, tandis que Sinon.js fournit une interface plus détaillée mais plus complexe que les utilisateurs familiers avec des outils de test similaires dans d'autres langues peuvent le préférer à autres .
• Fonction du traitement d'entrée: sinon.js permet une plus grande flexibilité dans les talons et les assertions d'utiliser les paramètres d'entrée sans nécessairement nécessiter des correspondances exactes, ce qui contraste avec l'exigence stricte de correspondance précise des paramètres par testdouble.js sauf si explicitement configuré.
• Prise en charge des promesses et des rappels: TestDouble.js intègre la prise en charge intégrée pour la promesse et fournit une gestion puissante de rappel, ce qui peut être plus adapté au développement de JavaScript moderne que Sinon.js, ce qui nécessite des informations supplémentaires. être réalisé.
• Fonction de remplacement du module: TestDouble.js prend en charge le remplacement de l'ensemble du module, qui est propice à l'isolement des interactions du module de test;
• Nettoyage et entretien: TestDouble.js simplifie le processus de nettoyage avec une seule fonction de réinitialisation, réduisant le risque de rester des stand-ins de test qui peuvent affecter d'autres tests, tandis que Sinon.js fournit plusieurs méthodes de nettoyage qui peuvent être plus difficiles à gérer à gérer .

les termes utilisés dans cet article

Pour assurer une compréhension facile de ce qui est discuté, voici un aperçu rapide des termes utilisés. Ce sont les définitions de Sinon.js et peuvent varier légèrement ailleurs.

• Testing stand-in est un remplacement des fonctions utilisées lors des tests. Il peut se référer à l'un des trois types mentionnés ci-dessous.
• SPY est un stand-in de test qui permet de vérifier l'effet sans affecter le comportement de la fonction objectif.
• Stume est un stand-in de test qui remplace le comportement de la fonction objectif par autre chose, comme la valeur de retour.
• La simulation est une approche différente de celle des talons. La simulation contient une validation intégrée, qui peut être un substitut à des affirmations distinctes.

Il convient de noter que l'un des objectifs de TestDouble.js est de réduire la confusion entre ce terme.

Aperçu de Sinon.js et TestDouble.js

Regardons d'abord la comparaison d'utilisation de base entre sinon.js et testdouble.js.

Sinon a trois concepts de stand-in de test différents: l'espion, les talons et les simulations. L'idée est que chacune représente un scénario d'utilisation différent. Cela rend la bibliothèque plus familière aux personnes d'autres langues ou qui ont lu des livres en utilisant la même terminologie, comme le mode de test Xunit. Mais d'un autre côté, ces trois concepts peuvent également rendre Sinon plus difficile à comprendre lorsqu'il est utilisé pour la première fois. Il s'agit d'un exemple de base d'utilisation de Sinon:

// 以下是查看函数调用的参数的方法：
var spy = sinon.spy(Math, 'abs');

Math.abs(-10);

console.log(spy.firstCall.args); // 输出：[ -10 ]
spy.restore();

// 以下是控制函数执行方式的方法：
var stub = sinon.stub(document, 'createElement');
stub.returns('not an html element');

var x = document.createElement('div');

console.log(x); // 输出：'not an html element'
stub.restore();

En revanche, TestDouble.js choisit une API plus simple. Au lieu d'utiliser des concepts comme les espions ou les talons, il utilise des langages que les développeurs JavaScript connaissent davantage, tels que td.function, td.object et td.replace. Cela rend Testdouble potentiellement plus facile à démarrer et plus adapté à certaines tâches. Mais d'un autre côté, certaines utilisations plus avancées peuvent tout simplement ne pas être possibles (ce qui est parfois intentionnel).

Ce qui suit est de savoir comment utiliser TestDouble.js:

// 以下是查看函数调用的参数的方法：
var abs = td.replace(Math, 'abs');

Math.abs(-10);

var explanation = td.explain(abs);
console.log(explanation.calls[0].args); // 输出：[ -10 ]

// 以下是控制函数执行方式的方法：
var createElement = td.replace(document, 'createElement');
td.when(createElement(td.matchers.anything())).thenReturn('not an html element');

var x = document.createElement('div');
console.log(x); // 输出：'not an html element'

// testdouble 使用一次调用重置所有测试替身，无需单独清理
td.reset();

TestDouble utilise un langage plus simple. Nous "remplaçons" la fonction au lieu de le "stub". Nous avons besoin de la fonction «Interprétation» TestDouble pour en obtenir des informations. En dehors de cela, c'est assez similaire à Sinon jusqu'à présent.

Cela s'étend également à la création de stand-in de test "anonyme":

var x = sinon.stub();

et

var x = td.function();

Les espions et les talons de Sinon ont des attributs qui fournissent plus d'informations à leur sujet. Par exemple, Sinon fournit des attributs tels que stub.callCount et stub.args. Dans le cas de TestDouble, nous obtenons ces informations de td.explain:

// 我们也可以为测试替身命名
var x = td.function('hello');

x('foo', 'bar');

td.explain(x);
console.log(x);
/* 输出：
{
  name: 'hello',
  callCount: 1,
  calls: [ { args: ['foo', 'bar'], context: undefined } ],
  description: 'This test double `hello` has 0 stubbings and 1 invocations.\n\nInvocations:\n  - called with `("foo", "bar")`.',
  isTestDouble: true
}
*/

L'une des plus grandes différences est liée à la façon dont les talons sont définis et la vérification est effectuée. Avec Sinon, vous pouvez lier les commandes après le stub et utiliser des assertions pour vérifier le résultat. TestDouble.js vous montre simplement comment vous souhaitez appeler une fonction - ou comment "répéter" un appel de fonction.

var x = sinon.stub();
x.withArgs('hello', 'world').returns(true);

var y = sinon.stub();
sinon.assert.calledWith(y, 'foo', 'bar');

et

var x = td.function();
td.when(x('hello', 'world')).thenReturn(true);

var y = td.function();
td.verify(y('foo', 'bar'));

Cela rend l'API de TestDouble plus facile à comprendre, car vous n'avez pas besoin de savoir quelles actions peuvent être liées à quand.

Comparez les tâches de test courantes plus en détail

À un niveau élevé, les deux bibliothèques sont assez similaires. Mais qu'en est-il des tâches de test courantes que vous pourriez avoir besoin pour effectuer dans un vrai projet? Voyons où certaines différences commencent à apparaître.

testdouble.js no espion

La première chose à noter est que TestDouble.js n'a pas le concept de "espion". Bien que Sinon.js nous permette de remplacer les appels de fonction pour obtenir des informations à partir d'eux tout en préservant le comportement par défaut de la fonction, ce n'est tout simplement pas possible dans TestDouble.js. Lorsque vous remplacez la fonction par TestDouble, elle perd toujours son comportement par défaut.

mais ce n'est pas nécessairement un problème. L'utilisation la plus courante des espions est de les utiliser pour vérifier que les rappels sont appelés, ce qui est facile à réaliser avec td.function:

var spy = sinon.spy();

myAsyncFunction(spy);

sinon.assert.calledOnce(spy);

et

var spy = td.function();

myAsyncFunction(spy);

td.verify(spy());

Bien que ce ne soit pas un gros problème, il est toujours important de noter cette différence entre les deux bibliothèques, sinon vous pourriez être surpris si vous vous attendez à pouvoir utiliser des espions dans TestDouble.js d'une manière plus spécifique.

testdouble.js nécessite une entrée plus précise

La deuxième différence que vous rencontrerez est que TestDouble est plus strict sur l'entrée.

Les talons et les affirmations de Sinon vous permettent d'être inexacts avec les paramètres fournis. C'est le plus facile à illustrer par l'exemple:

var stub = sinon.stub();
stub.withArgs('hello').returns('foo');

console.log(stub('hello', 'world')); // 输出：'foo'

sinon.assert.calledWith(stub, 'hello'); // 没有错误

et

// 以下是查看函数调用的参数的方法：
var spy = sinon.spy(Math, 'abs');

Math.abs(-10);

console.log(spy.firstCall.args); // 输出：[ -10 ]
spy.restore();

// 以下是控制函数执行方式的方法：
var stub = sinon.stub(document, 'createElement');
stub.returns('not an html element');

var x = document.createElement('div');

console.log(x); // 输出：'not an html element'
stub.restore();

Par défaut, Sinon ne se soucie pas du nombre de paramètres supplémentaires fournis à la fonction. Bien qu'il fournit des fonctions telles que sinon.assert.calledWithExactly, elle n'est pas recommandée comme valeur par défaut dans la documentation. Des fonctions comme stub.withArgs n'ont pas non plus de variantes "exactement".

testdouble.js, d'autre part, nécessite les paramètres exacts spécifiés par défaut. C'est par conception. L'idée est que si la fonction est fournie avec d'autres paramètres qui ne sont pas spécifiés dans le test, cela peut être une erreur et devrait échouer au test.

Les paramètres arbitraires peuvent être spécifiés dans TestDouble.js, mais ce n'est pas la valeur par défaut:

// 以下是查看函数调用的参数的方法：
var abs = td.replace(Math, 'abs');

Math.abs(-10);

var explanation = td.explain(abs);
console.log(explanation.calls[0].args); // 输出：[ -10 ]

// 以下是控制函数执行方式的方法：
var createElement = td.replace(document, 'createElement');
td.when(createElement(td.matchers.anything())).thenReturn('not an html element');

var x = document.createElement('div');
console.log(x); // 输出：'not an html element'

// testdouble 使用一次调用重置所有测试替身，无需单独清理
td.reset();

Utiliser ignoreExtraArgs: true, le comportement est similaire à Sinon.js.

TestDouble.js a un support de promesse intégré

Alors que l'utilisation de la promesse de Sinon.js n'est pas compliquée, TestDouble.js a des méthodes intégrées pour retourner et rejeter la promesse.

var x = sinon.stub();

et

var x = td.function();

Remarque : Vous pouvez utiliser Sinon-As promis pour inclure des fonctions pratiques similaires dans Sinon 1.x. Sinon 2.0 et les versions plus récentes incluent une prise en charge des promesses sous la forme de stub.resolves et stub.rejects.

La prise en charge de rappel pour TestDouble.js est plus puissante

Sinon et TestDouble offrent tous deux un moyen facile de faire les rappels de la fonction Stub. Cependant, il existe des différences dans leur fonctionnement.

Sinon utilise stub.yields pour faire de l'appel de talon la première fonction reçue comme paramètre.

// 我们也可以为测试替身命名
var x = td.function('hello');

x('foo', 'bar');

td.explain(x);
console.log(x);
/* 输出：
{
  name: 'hello',
  callCount: 1,
  calls: [ { args: ['foo', 'bar'], context: undefined } ],
  description: 'This test double `hello` has 0 stubbings and 1 invocations.\n\nInvocations:\n  - called with `("foo", "bar")`.',
  isTestDouble: true
}
*/

testdouble.js par défaut Mode de style nœud, où le rappel est supposé être le paramètre

Last . Vous n'avez pas à le spécifier lors de la répétition de l'appel:

var x = sinon.stub();
x.withArgs('hello', 'world').returns(true);

var y = sinon.stub();
sinon.assert.calledWith(y, 'foo', 'bar');

Ce qui rend le support de rappel de TestDouble plus puissant, c'est que vous pouvez facilement définir le comportement des scénarios avec plusieurs rappels ou différents ordres de rappels.

Supposons que nous voulons appeler

… callback1

var x = td.function();
td.when(x('hello', 'world')).thenReturn(true);

var y = td.function();
td.verify(y('foo', 'bar'));

Notez que nous passons

comme paramètre à la fonction dans td.callback. Cela indique à TestDouble quel paramètre nous voulons utiliser comme rappel. td.when

En utilisant Sinon, vous pouvez également changer de comportement:

var spy = sinon.spy();

myAsyncFunction(spy);

sinon.assert.calledOnce(spy);

Dans ce cas, nous utilisons

au lieu de callsArgWith. Nous devons fournir un indice spécifique de l'appel pour le faire fonctionner, ce qui peut être un peu lourd, en particulier sur les fonctions avec de nombreux paramètres. yields

Et si nous voulons appeler

deux rappels avec certaines valeurs?

var spy = td.function();

myAsyncFunction(spy);

td.verify(spy());

Avec Sinon, c'est tout simplement impossible. Vous pouvez lier plusieurs appels vers

, mais il n'appellera que l'un d'eux. callsArgWith

TestDouble.js a un remplacement de module intégré

En plus de pouvoir remplacer les fonctions par

, TestDouble vous permet également de remplacer l'ensemble du module. td.replace

Ceci est principalement utile si vous avez un module qui exporte directement les fonctions qui doivent être remplacées:

var stub = sinon.stub();
stub.withArgs('hello').returns('foo');

console.log(stub('hello', 'world')); // 输出：'foo'

sinon.assert.calledWith(stub, 'hello'); // 没有错误

Si nous voulons le remplacer par TestDouble, nous pouvons utiliser

, par exemple ... td.replace('path/to/file')

// 以下是查看函数调用的参数的方法：
var spy = sinon.spy(Math, 'abs');

Math.abs(-10);

console.log(spy.firstCall.args); // 输出：[ -10 ]
spy.restore();

// 以下是控制函数执行方式的方法：
var stub = sinon.stub(document, 'createElement');
stub.returns('not an html element');

var x = document.createElement('div');

console.log(x); // 输出：'not an html element'
stub.restore();

Bien que Sinon.js puisse remplacer les fonctions membres d'un objet, il ne peut pas remplacer des modules comme celui-ci. Pour ce faire lorsque vous utilisez Sinon, vous devez utiliser un autre module, comme Proxyquire ou Rewire.

// 以下是查看函数调用的参数的方法：
var abs = td.replace(Math, 'abs');

Math.abs(-10);

var explanation = td.explain(abs);
console.log(explanation.calls[0].args); // 输出：[ -10 ]

// 以下是控制函数执行方式的方法：
var createElement = td.replace(document, 'createElement');
td.when(createElement(td.matchers.anything())).thenReturn('not an html element');

var x = document.createElement('div');
console.log(x); // 输出：'not an html element'

// testdouble 使用一次调用重置所有测试替身，无需单独清理
td.reset();

Une autre chose que vous devez noter sur le remplacement du module est que TestDouble.js remplacera automatiquement l'ensemble du module. S'il s'agit d'une fonction d'exportation comme l'exemple ici, il remplace la fonction. S'il s'agit d'un objet contenant plusieurs fonctions, il les remplace tous. Les constructeurs et les classes ES6 sont également pris en charge. Proxyquire et Rewire exigent que vous spécifiez individuellement quoi et comment remplacer.

testdouble.js manquant certaines fonctions d'assistance pour sinon

Si vous utilisez le temporisateur d'émulation de Sinon, l'émulation XMLHTTPRequest ou le serveur d'émulation, vous remarquerez qu'ils n'existent pas dans le testdouble.

La minuterie d'émulation peut être utilisée comme plugin, mais les fonctions XMLHTTPREQUESS et AJAX doivent être gérées de différentes manières.

Une solution simple consiste à remplacer la fonction ajax que vous utilisez, par exemple $.post:

var x = sinon.stub();

Il est plus facile de nettoyer le contenu de test à l'aide de testdouble.js

Une pierre d'achoppement commune pour les débutants de Sinon.js est souvent de nettoyer les espions et les talons. Sinon propose trois différentes façons de le faire, ce qui n'aide pas beaucoup.

var x = td.function();

ou:

// 我们也可以为测试替身命名
var x = td.function('hello');

x('foo', 'bar');

td.explain(x);
console.log(x);
/* 输出：
{
  name: 'hello',
  callCount: 1,
  calls: [ { args: ['foo', 'bar'], context: undefined } ],
  description: 'This test double `hello` has 0 stubbings and 1 invocations.\n\nInvocations:\n  - called with `("foo", "bar")`.',
  isTestDouble: true
}
*/

ou:

var x = sinon.stub();
x.withArgs('hello', 'world').returns(true);

var y = sinon.stub();
sinon.assert.calledWith(y, 'foo', 'bar');

Habituellement, il est recommandé d'utiliser des méthodes de bac à sable et

, sinon il est facile de laisser accidentellement des talons ou des espions, ce qui peut entraîner des problèmes avec d'autres tests. Cela peut entraîner des échecs en cascade difficiles à tracer. sinon.test

testdouble.js ne fournit qu'un moyen de nettoyer et de tester le stand-in:

. La méthode recommandée consiste à l'appeler dans le td.reset() Hook: afterEach

var x = td.function();
td.when(x('hello', 'world')).thenReturn(true);

var y = td.function();
td.verify(y('foo', 'bar'));

Cela simplifie considérablement la configuration du respect et le nettoyage du test après les tests, en réduisant la possibilité d'erreurs difficiles à suivre.

Avant et contre

Nous avons maintenant compris les fonctionnalités de ces deux bibliothèques. Ils offrent tous les deux un ensemble de fonctionnalités assez similaire, mais ils ont des idées de conception différentes les unes des autres. Pouvons-nous le décomposer en avantages et inconvénients?

Parlons d'abord de Sinon.js. Il fournit quelques fonctionnalités supplémentaires que TestDouble.js et certains aspects de celle-ci sont plus faciles à configurer. Cela offre une plus grande flexibilité pour cela dans des scénarios de test plus spéciaux. Sinon.js utilise également le langage des personnes qui connaissent davantage d'autres langues - des concepts tels que des espions, des talons et des simulations existent dans différentes bibliothèques et ont également été discutés dans des livres liés aux tests.

L'inconvénient est qu'il augmente la complexité. Bien que sa flexibilité permet aux experts de faire plus de choses, cela signifie que certaines tâches sont plus complexes que dans TestDouble.js. Il peut également avoir une courbe d'apprentissage plus abrupte pour les nouveaux pour tester le concept de remplaçant. En fait, même quelqu'un aussi familier que moi peut avoir du mal à expliquer en détail certaines des différences entre

et sinon.stub! sinon.mock

testdouble.js a sélectionné une interface plus simple. La plupart de son contenu est assez simple et facile à utiliser et se sent mieux adapté à JavaScript, tandis que Sinon.js a parfois l'impression d'être conçu pour d'autres langues. Grâce à cela et à certains des principes de conception, il est plus facile pour les débutants de commencer, et même les testeurs expérimentés trouveront de nombreuses tâches plus faciles à accomplir. Par exemple, TestDouble utilise la même API pour configurer des stand-ins de test et vérifier les résultats. Il peut également être moins sujet aux erreurs en raison de son mécanisme de nettoyage plus simple.

Testdouble Le plus gros problème est causé par certains de ses principes de conception. Par exemple, un manque complet d'espions peut empêcher certaines personnes qui préfèrent utiliser des espions sur des talons. C'est en grande partie une question d'opinion et vous ne trouverez peut-être pas du tout le problème. En plus de cela, bien que TestDouble.js soit une bibliothèque mise à jour, elle fournit une concurrence sérieuse pour Sinon.js.

Comparez par fonction

Ce qui suit est une comparaison par fonction:

功能	Sinon.js	testdouble.js
间谍	是	否
存根	是	是
延迟存根结果	否	是
模拟	是	是1
Promise 支持	是（在 2.0 中）	是
时间辅助函数	是	是（通过插件）
Ajax 辅助函数	是	否（改为替换函数）
模块替换	否	是
内置断言	是	是
匹配器	是	是
自定义匹配器	是	是
参数捕获器	否2	是
代理测试替身	否	是

1. testdouble.js Parlant techniquement Il n'y a pas de simulation comme celle de Sinon.js. Cependant, comme la simulation de Sinon est essentiellement un objet qui contient des talons et une validation, des effets similaires peuvent être obtenus en utilisant td.replace(someObject).
2. peut être obtenu des effets similaires à ceux des captures de paramètres en utilisant stub.yield (à ne pas confondre avec stub.yields).

Résumé et conclusion

sinon.js et testdouble.js fournissent tous deux un ensemble de fonctionnalités assez similaire. À cet égard, ni l'un ni l'autre n'est évidemment supérieur.

La plus grande différence entre les deux est leur API. Sinon.js est probablement un peu plus long et offre de nombreuses options sur la façon de faire les choses. Cela peut être ses avantages et ses inconvénients. TestDouble.js a une API plus maigre, ce qui facilite l'apprentissage et l'utilisation, mais en raison de sa conception plus arbitraire, certains peuvent le trouver problématique.

Alors, lequel me convient?

Êtes-vous d'accord avec les principes de conception de TestDouble? Si c'est le cas, il n'y a aucune raison de ne pas l'utiliser. J'ai utilisé Sinon.js dans de nombreux projets et je peux dire en toute sécurité que TestDouble.js fait au moins 95% du travail que j'ai fait dans Sinon.js et les 5% restants peuvent être effectués avec une solution de contournement simple.

Si vous trouvez Sinon.js difficile à utiliser ou si vous recherchez un testdouble.js plus "de style javascript" pourrait également être pour vous. Même des gens comme moi qui passent beaucoup de temps à apprendre à utiliser Sinon, j'ai tendance à suggérer d'essayer TestDouble.js et voir si vous l'aimez.

Cependant, certains aspects de TestDouble.js peuvent provoquer des maux de tête pour ceux qui ont connaissance de Sinon.js ou d'autres testeurs expérimentés. Par exemple, le manque total d'espions peut être le facteur décisif. Sinon.js est toujours un bon choix pour les experts et ceux qui veulent le plus de flexibilité.

Si vous souhaitez en savoir plus sur la façon d'utiliser des stand-ins de test dans la pratique, consultez mon guide Sinon.js gratuit. Bien qu'il utilise Sinon.js, vous pouvez également appliquer les mêmes techniques et meilleures pratiques pour testerdouble.js.

y a-t-il des problèmes? Commentaire? Utilisez-vous déjà TestDouble.js? Après avoir lu cet article, envisageriez-vous de l'essayer? Veuillez me le faire savoir dans les commentaires ci-dessous.

Cet article a été examiné par James Wright, Joan Yin, Christian Johansen et Justin Searls. Merci à tous les pair de sitepoint pour avoir obtenu le contenu de sitepoint à son meilleur!

Des questions fréquemment posées sur les outils de test JavaScript: sinon.js vs testdouble.js

Quelle est la principale différence entre sinon.js et testdouble.js?

sinon.js et testdouble.js sont tous deux des bibliothèques de test JavaScript populaires, mais elles ont des différences clés. Sinon.js est connu pour son riche ensemble de fonctionnalités, y compris les espions, les talons et les simulations, ainsi que pour les utilitaires pour imiter les minuteries et XHR. Il s'agit d'un outil polyvalent qui peut être utilisé en conjonction avec n'importe quel cadre de test. D'un autre côté, TestDouble.js est une bibliothèque minimaliste qui se concentre sur la fourniture d'une API simple et intuitive pour tester les stand-ins, qui sont des alternatives aux parties du système à tester. Il n'inclut pas les services publics pour émuler des minuteries ou des XHR, mais il est conçu pour être facile à utiliser et à comprendre, c'est donc une excellente option pour ceux qui préfèrent une méthode de test plus maigre.

Comment installer sinon.js et testdouble.js?

sinon.js et testdouble.js peuvent être installés via NPM (Node.js Package Manager). Pour Sinon.js, vous pouvez utiliser la commande npm install sinon. Pour TestDouble.js, la commande est npm install testdouble. Après l'installation, vous pouvez utiliser const sinon = require('sinon') et const td = require('testdouble') pour les introduire dans vos fichiers de test, respectivement.

Puis-je utiliser Sinon.js et TestDouble.js en même temps?

Oui, Sinon.js et TestDouble.js peuvent être utilisés simultanément dans le même projet. Ils sont tous conçus pour être très bien simples et bien fonctionner avec d'autres bibliothèques. Cependant, n'oubliez pas qu'ils ont des fonctionnalités qui se chevauchent, donc les utiliser en même temps peut entraîner une confusion. Il est généralement recommandé de choisir l'un d'eux en fonction de vos besoins et préférences spécifiques.

Comment créer un espion en utilisant sinon.js et testdouble.js?

Dans sinon.js, vous pouvez utiliser sinon.spy() pour créer des espions. Cette fonction renvoie un objet d'espion qui enregistre tous les appels qui y sont passés, y compris les paramètres, les valeurs de retour et les exceptions. Dans TestDouble.js, vous pouvez créer des espions en utilisant td.function(). Cette fonction renvoie une fonction autonome de test qui enregistre tous les appels, y compris les paramètres.

Comment créer des talons à l'aide de sinon.js et testdouble.js?

Dans sinon.js, vous pouvez créer des talons en utilisant sinon.stub(). Cette fonction renvoie un objet Stub qui se comporte comme un espion, mais il vous permet également de définir son comportement, comme spécifier une valeur de retour ou lancer une exception. Dans TestDouble.js, vous pouvez créer des talons en utilisant td.when(). Cette fonction vous permet de définir votre comportement lors de l'appel d'une veille de test avec un paramètre spécifique.

Comment utiliser sinon.js et testdouble.js pour vérifier les espions ou les talons?

Dans sinon.js, vous pouvez utiliser des méthodes telles que spy.called, spy.calledWith() et spy.returned() pour vérifier les espions ou les talons. Dans TestDouble.js, vous pouvez utiliser td.verify() pour affirmer si la veille du test est appelée d'une manière ou d'une autre.

Quels sont les avantages de l'utilisation de sinon.js au lieu de testdouble.js?

sinon.js a un ensemble de fonctionnalités plus complet par rapport à TestDouble.js. Il comprend des services publics pour émuler les minuteries et XHR, ce qui est très utile pour tester certains types de code. Il est également utilisé plus largement et dispose d'une communauté plus large, ce qui signifie que plus de ressources et de soutien peuvent être obtenues.

Quels sont les avantages de l'utilisation de testdouble.js au lieu de sinon.js?

TestDouble.js a une API plus simple et plus intuitive que Sinon.js. Il est conçu pour être facile à utiliser et à comprendre, c'est donc un excellent choix pour ceux qui préfèrent une méthode de test plus rationalisée. Il encourage également de bonnes pratiques de test en rendant difficile la maltraitance des stand-ins de tests.

Puis-je utiliser sinon.js et testdouble.js avec d'autres cadres de test?

Oui, Sinon.js et TestDouble.js sont tous deux conçus très soigneusement et fonctionnent bien avec d'autres cadres de test. Ils peuvent être utilisés avec n'importe quel cadre de test compatible JavaScript.

Quelles ressources y a-t-il pour en savoir plus sur Sinon.js et TestDouble.js?

Oui, Sinon.js et TestDouble.js ont beaucoup de documentation sur leurs sites Web officiels. Il existe également de nombreux tutoriels, articles de blog et cours en ligne couvrant le contenu approfondi de ces bibliothèques.

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!