Processus Windows 7 cachés. Comment trouver et supprimer un processus viral ? Est-il possible de déterminer le processus "de gauche"

Et c'est l'outil de test officiel de jQuery. Mais QUnit est idéal pour tester n'importe quel code JavaScript et peut même tester le backend JavaScript à l'aide de moteurs comme Rhino ou V8.

Si vous n'êtes pas familier avec l'idée des "tests unitaires", ne vous inquiétez pas, il n'y a rien de compliqué là-dedans :

"Tests unitaires ou tests unitaires (anglais) tests unitaires) est un processus de programmation qui vous permet de vérifier l’exactitude des modules individuels du code source d’un programme. L'idée est d'écrire des tests pour chaque fonction ou méthode non triviale. Cela vous permet de vérifier rapidement si le prochain changement de code a conduit à régression, c'est-à-dire à l'apparition d'erreurs dans des endroits déjà testés du programme, et facilite également la détection et l'élimination de ces erreurs."

Définition citée sur Wikipédia. Faites simplement des tests pour chaque bloc fonctionnel de votre code, et si tous les tests réussissent, vous pouvez être sûr qu'il n'y a pas d'erreurs (cela dépend principalement du soin avec lequel les tests sont conçus).

Pourquoi devriez-vous tester votre code

Si vous n'avez jamais écrit de tests unitaires auparavant, vous avez probablement simplement hébergé votre code directement sur un serveur Web, l'avez exécuté, surveillé les erreurs et essayé de les corriger au fur et à mesure qu'elles étaient trouvées. Cette méthode de travail pose de nombreux problèmes.

Premièrement, c'est une activité très fastidieuse et ennuyeuse. La validation est en fait un travail assez difficile car il faut être sûr que tout a été pressé. Et dans ce processus, il y a une très forte probabilité qu’un ou deux points soient manqués.

Deuxièmement, tout ce qui est fait pour ces tests ne peut pas être réutilisé. Avec cette méthode, il est très difficile de trouver des régressions. Que sont les régressions ? Imaginez que vous ayez écrit du code et que vous l'ayez testé, corrigé toutes les erreurs que vous avez trouvées et placé le code sur le site. L'utilisateur a ensuite envoyé des commentaires sur les nouveaux bugs et une demande de nouvelles fonctionnalités. Vous revenez au code, corrigez les bugs et ajoutez de nouvelles fonctionnalités. Dans ce cas, une situation peut survenir où d'anciennes erreurs réapparaissent, ce que l'on appelle « régression ». Vous devez tout vérifier à nouveau. Et il y a une chance que vous ne retrouviez pas vos vieilles erreurs. Dans tous les cas, il faudra du temps avant de se rendre compte que le problème est dû à une « régression ». Lorsque vous utilisez des tests unitaires, vous écrivez un test. Une fois le code modifié, vous le filtrez à nouveau via le test. Si une régression se produit, certains tests échoueront et vous pourrez facilement déterminer quelle partie du code contient l'erreur. Puisque vous savez ce que vous avez modifié, l’erreur sera facile à corriger.

Un autre avantage des tests unitaires (en particulier pour le développement Web) est qu'il est facile de tester la compatibilité entre navigateurs. Il vous suffit d'exécuter des tests dans différents navigateurs. Si des problèmes sont détectés dans le navigateur, vous pouvez les résoudre et relancer le test. En conséquence, vous serez sûr que tous les navigateurs cibles sont pris en charge puisqu’ils ont tous été testés.

Comment écrire des tests unitaires dans QUnit

Alors, comment écrire directement des tests unitaires dans QUnit ? La première étape consiste à installer l'environnement de test :

Suite de tests QUnit Suite de tests QUnit

Le code qui sera testé va dans le fichier myProject.js et les tests vont dans myTests.js. Pour exécuter les tests, il vous suffit d'ouvrir le fichier HTML dans votre navigateur. Il est maintenant temps d'écrire un test.

L’élément constitutif des tests unitaires est l’assertion.

"Une assertion est une expression qui prédit le résultat renvoyé lorsque votre code est exécuté. Si la prédiction est incorrecte, alors l'assertion a une valeur FAUX, ce qui nous permet de tirer des conclusions sur la présence d'erreurs."

Pour exécuter des assertions, elles doivent être placées dans un bloc de test :

// teste cette fonction function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zéro est un nombre pair"); ok ( isEven(2), "Deux est aussi"); ok(isEven(-4), "Et moins quatre est aussi un nombre pair"); ok(!isEven(1), "Un est un nombre impair"); isEven(-7), "Comme moins sept est un nombre impair");

Ici, nous définissons une fonction est pair, qui vérifie la parité d'un nombre, et nous voulons nous assurer que cette fonction ne renvoie pas de valeurs erronées.

Nous appelons d’abord la fonction test(), qui construit un bloc de test. Le premier paramètre est la chaîne qui sera générée en conséquence. Le deuxième paramètre est une fonction de retour qui contient nos assertions. Cette fonction de rappel sera appelée une fois lors de l'exécution de QUnit.

Nous avons écrit cinq déclarations, qui sont toutes logiques. L'énoncé logique suppose que le premier paramètre a une valeur vrai. Le deuxième paramètre est le message affiché dans le résultat.

Voici ce que nous obtenons après avoir exécuté le test :

Toutes nos déclarations ont été confirmées avec succès, nous pouvons donc supposer que la fonction estPair() fonctionne comme prévu.

Voyons ce qui se passe si la déclaration est fausse.

// teste cette fonction function isEven(val) ( return val % 2 === 0; ) test("isEven()", function() ( ok(isEven(0), "Zéro est un nombre pair"); ok ( isEven(2), "Deux est aussi"); ok(isEven(-4), "Et moins quatre est aussi un nombre pair"); ok(!isEven(1), "Un est un nombre impair"); isEven(-7), "Comme moins sept est un nombre impair"); // Erreur ok(isEven(3), "Trois est un nombre pair");

Et voici ce que nous obtenons en exécutant le test :

La déclaration contient une erreur que nous avons commise intentionnellement. Mais dans votre projet, si certains tests échouent et que toutes les autres déclarations sont correctes, il sera alors très facile de trouver l'erreur.

Autres déclarations

ok() n'est pas la seule instruction prise en charge par QUnit. Il existe d'autres types d'assertions utiles à utiliser lors de la rédaction de tests pour vos projets :

Déclaration de comparaison

Déclaration de comparaison est égal() suppose que le premier paramètre (qui est la valeur réelle) est équivalent au deuxième paramètre (qui est la valeur attendue). Cette déclaration est très similaire à d'accord(), mais il génère à la fois des valeurs réelles et attendues, ce qui facilite grandement le débogage du code. Tout comme d'accord(), est égal() peut accepter un message pour la sortie comme troisième paramètre.

Alors à la place

Test("assertions", function() ( ok(1 == 1, "un équivaut à un"); ))

Doit être utilisé :

Test("assertions", function() ( equals(1, 1, "un équivaut à un"); ))

Notez que la valeur attendue est imprimée à la fin de la ligne.

Et si les valeurs ne sont pas égales :

Test("assertions", function() ( equals(2, 1, "un équivaut à un"); ))

Cette entrée donne plus d'informations.

L'assertion de comparaison utilise l'opérateur « == » pour tester les paramètres, elle ne peut donc pas fonctionner avec des tableaux ou des objets :

Test("test", function() ( égal((), (), "erreur, ce sont des objets différents"); égal((a: 1), (a: 1) , "erreur"); égal à(, , "erreur, ce sont des tableaux différents"); equals(, , "erreur");

Pour de tels cas, QUnit dispose d'une assertion d'identité.

Affirmation d'identité

Affirmation d'identité même() utilise les mêmes paramètres que est égal(), mais cela fonctionne non seulement avec les types primitifs, mais aussi avec les tableaux et les objets. Les instructions de l'exemple précédent réussiront le test si elles sont remplacées par des instructions d'identité :

Test("test", function() ( identique((), (), "passes, les objets ont le même contenu"); identique((a: 1), (a: 1) , "passes"); identique( , , "passes, les tableaux ont le même contenu"); identique(, , "passes");

Veuillez noter que même() utilise l'opérateur '===' pour la comparaison, il est donc pratique à utiliser pour comparer des valeurs spéciales :

Test("test", function() ( égal(0, faux, "vrai"); identique(0, faux, "faux"); égal(null, non défini, "vrai"); identique(null, non défini, " FAUX"); ))

Structure de la déclaration

Placer toutes les assertions dans un seul test est une très mauvaise idée. Un tel test sera difficile à maintenir et vous pourriez vous perdre dans l'évaluation des résultats de son exécution. Par conséquent, vous devez structurer le test en plaçant les instructions dans des blocs séparés, chacun étant destiné à un groupe spécifique de fonctions.

Vous pouvez organiser des modules individuels à l'aide d'un appel de fonction module:

Module("ModuleA"); test("Test", fonction() ()); test("Un autre test", function() ()); module("ModuleB"); test("Test", fonction() ()); test("Un autre test", function() ());

Dans l'exemple précédent, toutes les instructions étaient appelées de manière synchrone, c'est-à-dire qu'elles étaient exécutées les unes après les autres. Il existe de nombreuses fonctions asynchrones dans le monde réel, telles que les requêtes ou fonctions AJAX setTimeout() Et setInterval(). Comment tester ce type de fonctionnalité ? QUnit a un type de test spécial appelé « test asynchrone » qui est conçu pour les tests asynchrones :

Tout d’abord, essayons d’écrire un test de la manière habituelle :

Test("Test asynchrone", function() ( setTimeout(function() ( ok(true); ), 100) ))

Il semble qu'il n'y ait aucune assertion dans le test. Parce que l'instruction a été exécutée de manière synchrone, mais au moment où la fonction a été appelée, le test était déjà terminé.

La bonne façon de tester notre exemple est la suivante :

Test("Test asynchrone", function() ( // Mettre le test en mode pause stop(); setTimeout(function() ( ok(true); // Après avoir appelé l'assertion // continuer le test start(); ) , 100) ))

Nous avons utilisé la fonction arrêt() pour arrêter le test, et après avoir exécuté l'assertion, réexécutez le test en utilisant la fonction commencer().

Appeler une fonction arrêt() immédiatement après avoir appelé la fonction test() est une pratique très courante. C'est pourquoi QUnit a une abréviation spéciale : asyncTest(). L'exemple précédent peut être réécrit comme suit :

AsyncTest("Test asynchrone", function() ( // Le test passe automatiquement en mode "pause" setTimeout(function() ( ok(true); // Après avoir appelé l'assertion // continue le test start(); ) , 100) ) )

Il y a un point qui mérite réflexion : la fonction setTimeout() appelle toujours sa fonction de rappel, et si vous testez une autre fonction (par exemple, un appel AJAX). Comment être sûr que la fonction de rappel sera appelée ? Si la fonction de retour n'est pas appelée, la fonction commencer() restera également non appelé et l'ensemble du test se figera :

Vous pouvez organiser le test comme suit :

// Fonction personnalisée function ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Asynchronous test", function() ( // Arrête le test et // rapporte une erreur si la fonction start() n'est pas appelée après 1 seconde stop(1000); ajax(function() ( // ...instruction asynchrone start(); )) ))

Pour fonctionner arrêt() la valeur du timeout est transmise. Maintenant, QUnit reçoit l'information : "si la fonction commencer() ne sera pas appelé après l'expiration du délai d'attente, ce test doit être considéré comme un échec. Désormais, l'ensemble du test ne sera plus gelé et un avertissement sera émis en cas de problème.

Considérons maintenant le cas de plusieurs fonctions asynchrones. Où placer la fonction commencer()? Il faut le mettre dans une fonction setTimeout():

// Fonction personnalisée function ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Async test", function() ( // Arrêter l'arrêt du test(); ajax (function() ( // ...instruction asynchrone )) ajax(function() ( // ...instruction asynchrone )) setTimeout(function() ( start(); ), 2000 ));

La valeur du délai d'attente doit être suffisante pour permettre aux deux rappels de se terminer avant la poursuite du test. Si l’une des fonctions n’est pas appelée, comment déterminer laquelle ? Il y a une fonction pour ça attendre():

// Fonction personnalisée function ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) test("Asynchronous test", function() ( // Arrêter l'arrêt du test(); / / Indique à QUnit que nous nous attendons à ce que trois instructions soient exécutées expect(3); ajax(function() ( ok(true); )) ajax(function() ( ok(true); ok(true); )) setTimeout( fonction( ) ( start(); ), 2000 ))

On passe à la fonction attendre() le nombre d'instructions dont l'exécution est prévue. Si l'une des déclarations échoue, vous recevrez un message indiquant que quelque chose ne se passe pas comme prévu.

Il y a un court enregistrement que vous pouvez utiliser attendre(): vous devez passer le nombre d'instructions planifiées comme deuxième paramètre test() ou asyncTest():

// Fonction personnalisée function ajax(successCallback) ( $.ajax(( url: "server.php", success: successCallback )); ) // Indique à QUnit que nous nous attendons à ce que 3 instructions soient exécutées test("asynchronous test", 3 , function() ( // Arrêter le test stop(); ajax(function() ( ok(true); )) ajax(function() ( ok(true); ok(true); )) setTimeout(function() ( début (); ), 2000);

Conclusion

Dans ce didacticiel, nous avons fourni tout ce dont vous avez besoin pour démarrer avec QUnit. Les tests unitaires sont une excellente méthode pour tester le code avant de l'utiliser. Si vous n’avez jamais utilisé de tests auparavant, c’est le moment de commencer.