Semaine 6 – Validation et Vérification des logiciels

Validation et Vérification des logiciels

Avec du matériel de Nikolay Radoev et Kevin Gauthier

Génie informatique et génie logiciel – LOG2440 A2024 1

 Semaine 6 – Validation et Vérification des logiciels

Plan de la séance
● Validation et Vérification
● Tests
○ Types de tests
○ Catégories de tests
● Pratiques de tests
○ Planifications des tests
○ Métriques de tests
● Outils de tests
○ Librairies de test JS
○ Outils de vérification automatisés

Génie informatique et génie logiciel – LOG2440 A2024 2

 Semaine 6 – Validation et Vérification des logiciels

Validation et Vérification
● Validation : le logiciel répond aux besoins des utilisateurs
● Vérification : le logiciel se comporte comme prévu.

● Barry Boehm propose les définitions suivantes :

○ Validation : Est-ce quʼon construit le bon produit ? (Are we building the right product ?)
○ Vérification : Est-ce quʼon construit bien le produit ? (Are we building the product right ?)

● Un logiciel peut donc être vérifié sans être validé et vice-versa.

○ Exemple : logiciel sans bogues, mais sans toutes les fonctionnalités demandées

Génie informatique et génie logiciel – LOG2440 A2024 3

 Semaine 6 – Validation et Vérification des logiciels

Validation et Vérification : Tests

● Lʼutilité dʼun processus se base sur les actions effectuées durant son exécution.
○ Ici, les actions principales sont les Tests.

● Le choix du type de tests dépend largement de la nature du projet :

○ On ne teste pas un appareil médical comme on teste un jeu vidéo.

● Lʼautomatisation des tests (si possible) offre un grand avantage lors du développement.
○ Ex : un outil qui exécute les tests après chaque nouveau commit sur Git

Génie informatique et génie logiciel – LOG2440 A2024 4

 Semaine 6 – Validation et Vérification des logiciels

Tests
● Le but dʼun test est de trouver des erreurs et non prouver leur absence.
○ Une preuve complète est très difficile, voire impossible dans des logiciels complexes.

Quelques définitions :
● Processus qui exécute un programme pour y trouver des erreurs. (Glenford Myers)
○ Définition limitée aux erreurs qui peuvent être détectées à travers lʼexécution du code.

● Ensemble dʼentrées qui produisent un ensemble de états ou comportements attendus

< { entrées }, { états/comportements attendus } >

Génie informatique et génie logiciel – LOG2440 A2024 5

 Semaine 6 – Validation et Vérification des logiciels

Tests
La deuxième définition permet de couvrir des tests précis ainsi que des tests plus larges nʼétant
pas nécessairement liés à lʼexécution du programme.

Exemple : Exemple :
const add = (a,b) => a + b ; Document dʼarchitecture qui décrit un contact
avec une base de données dans le projet.
Test1 = <{1,2} , {3} >
Test2 = <{-5,5}, {0} > Test = <{ Projet }, { Présence de BD } >
Test3 = <{1,2} , {4} > (devrait échouer) Si le test échoue, on a un problème de
Test4 = <{"1",1}, {2} > (manque de validation) cohérence entre le design et lʼimplémentation

Génie informatique et génie logiciel – LOG2440 A2024 6

 Semaine 6 – Validation et Vérification des logiciels

Exemples de types fréquents

● Les tests peuvent prendre plusieurs formes en fonction du projet et leur objectifs :
○ Tests unitaires
LOG2440 se concentre sur ces tests
○ Tests dʼintégration
○ Tests de système Il existe un grand nombre de tests qui peuvent
○ Tests dʼacceptation sʼappliquer en fonction des besoins.
○ Tests de sécurité
Certains demandent même une expertise
○ Tests de charge, de capacité spécifique et ne sont pas fait directement par
○ Tests dʼutilisabilité les développeurs du logiciel.
○ Tests de plateformes
○ Etc.
Exemples suivants basés sur ce projet sur GitHub

Génie informatique et génie logiciel – LOG2440 A2024 7

 Semaine 6 – Validation et Vérification des logiciels

Tests unitaires
Système
C E

A B

D
Utilisateur

● Tests unitaires
○ Limités à une unité (fonction, classe simple, etc.)
○ Testent les entrées/sorties ou les branches de décisions dʼune méthode.
○ Unité testée en isolation, sans le reste du système.

Génie informatique et génie logiciel – LOG2440 A2024 8

 Semaine 6 – Validation et Vérification des logiciels

Exemple de tests unitaires

inputValidator(input, min, max) { return input >= min && input <= max; }

TESTS:
it("inputValidator should return true if value is between min and max"
, () => {
expect([Link](5, 0, 10)).toBeTruthy();
});
Les tests couvrent les cas
d’entrées valides, mais surtout
it("inputValidator should return false if value is under min"
, () => { les cas d’entrées invalides
expect([Link](-5, 0, 10)).toBeFalsy();
});
Question : quelles autres
valeurs seraient intéressantes
it("inputValidator should return false if value is over max"
, () => { à couvrir avec ce code ?
expect([Link](15, 0, 10)).toBeFalsy();
});
Génie informatique et génie logiciel – LOG2440 A2024 9
 Semaine 6 – Validation et Vérification des logiciels

Tests dʼintégration
Système
C E

A B

D
Utilisateur

● Tests dʼintégration :
○ 2+ composantes, parfois développées par des personnes différentes
○ Testent l'interaction entre les composantes
○ Isolation partielle : recherche dʼerreurs potentielles lors de lʼinteraction entre les composantes

Génie informatique et génie logiciel – LOG2440 A2024 10

 Semaine 6 – Validation et Vérification des logiciels

Exemple de tests dʼintégration

class PolyPaint { ...
[Link]("input-color").addEventListener("change", (event) => {
const newColor = [Link];
if ([Link](newColor)) { [Link](newColor);}
});
}
TEST:
it('Should change the color of the tool', () => {
[Link] = new Pencil('pencil', 1, [Link]('2d'));
const color = "#00ff00";
const input = [Link]("input-color"); On teste le lien entre les méthodes
[Link] = color; des classes PolyPaint et Pencil
[Link](new Event("change")); (attribut currentTool) et l'interaction
avec le DOM et PolyPaint
expect([Link]).toBe(color);
});
Génie informatique et génie logiciel – LOG2440 A2024 11
 Semaine 6 – Validation et Vérification des logiciels

Tests de système
Système
C E

A B

D
Utilisateur

● Tests de système :
○ Exécution du système (1 ou plusieurs logiciels) au complet
○ Interactions entre les différentes composantes du système (logicielles et matérielles)
○ Généralement faits de manière automatisée sans lʼutilisateur.
■ End To End : test de bout en bout qui simule un utilisateur et son interaction avec le système

Génie informatique et génie logiciel – LOG2440 A2024 12

 Semaine 6 – Validation et Vérification des logiciels

Exemple de tests de système Ce test simule un utilisateur qui change la

couleur et dessine une ligne droite

// Construire les classes nécessaires // Dessiner une ligne de {x:10,y:10} à {x:20,y:10}

const drawingCanvas = loadCanvas(); [Link](
const pencil = new Pencil( configureEvent("mousedown", 10, 10));
"pencil", 5, [Link]); [Link](
polyPaint = new PolyPaint( configureEvent("mousemove", 20, 10));
[Link], [pencil]); [Link](
[Link](); configureEvent("mouseup", 20, 10));

// Émuler un changement de couleur // Récupérer un pixel et vérifier sa couleur RGBA

const input = const imageData = [Link]("2d")
[Link]("input-color"); .getImageData(15, 10, 1, 1).data;
[Link] = "#ff00ff"; // 255,0,255
[Link](new Event("change")); expect([Link](imageData))
.toEqual([255, 0, 255, 255]);

Génie informatique et génie logiciel – LOG2440 A2024 13

 Semaine 6 – Validation et Vérification des logiciels

Tests dʼacceptation
Système
C E

A B

D
Utilisateur

● Tests dʼacceptation :
○ Exécution du système avec les parties prenantes (clients, utilisateurs, etc.)
○ Interactions entre lʼutilisateur et le système : valider si le logiciel correspond aux besoins énoncés
○ À ne pas faire juste à la fin : lʼapproche par prototypes est utilisée durant le développement.
■ Ex : les phases dʼAlpha et Beta pour des jeux vidéo ou des grands logiciels.

Génie informatique et génie logiciel – LOG2440 A2024 14

 Semaine 6 – Validation et Vérification des logiciels

Tests de régression
Système
C E

A B

D
Utilisateur

● Tests de régression :
○ Réutilisation des tests existants pour trouver si des changements ont apporté des défauts
○ Testent ce qui a été modifié depuis la dernière phase de tests
○ Pas un type de test différent en soi, mais plutôt une utilité des tests existants
Les tests unitaires, intégration, etc. peuvent aussi être des tests de régression
Génie informatique et génie logiciel – LOG2440 A2024 15
 Semaine 6 – Validation et Vérification des logiciels

Catégories des tests

Généralement 2 grandes catégories qui classifient les tests, mais dʼautres en existent :

● Tests en Boîte noire :

○ On sʼintéresse seulement aux entrées et sorties.
○ Le test nʼa pas connaissance de la structure interne de ce qui est testé.

● Tests en Boîte blanche :

○ On sʼintéresse à la structure interne de ce qui est testé.
○ Le test a une connaissance complète de la structure de ce qui est testé.

Génie informatique et génie logiciel – LOG2440 A2024 16

 Semaine 6 – Validation et Vérification des logiciels

Tests en boîte noire

● Validation du comportement de lʼélément testé .
○ Valide quʼun ensemble dʼentrées produit un ensemble de sorties/comportements.
● Tests de haut niveau (intégration, système, acceptation, etc.) sont souvent en boîte noire
○ On peut également avoir des tests unitaires en boîte noire.

● On peut écrire les tests avant même lʼimplémentation, si on connaît les entrées et sorties.
○ Le TDD (Test Driven Development) est la pratique dʼécrire les tests avant le code.
■ Peut éliminer le biais du développeur qui teste son propre code.

Génie informatique et génie logiciel – LOG2440 A2024 17

 Semaine 6 – Validation et Vérification des logiciels

Tests en boîte noire : exemple

Exemple dʼun bouton pause/play dʼune vidéo sur une page web
function playVideo(){
const video = [Link]('video');
if([Link])
[Link]();
else
[Link]();
}

[Link]('click',playVideo);

Tests en boîte noire :

Test1 : < {Vidéo en pause, click} , { Vidéo qui joue } >
Test2 : < {Vidéo qui joue , click} , { Vidéo en pause } >

Génie informatique et génie logiciel – LOG2440 A2024 18

 Semaine 6 – Validation et Vérification des logiciels

Tests en boîte blanche

● Vérification de la logique de lʼélément testé.
○ Vérifient le comportement de la structure interne.
○ Ne testent que le code existant : ne peuvent pas détecter des fonctionnalités absentes.

● Les tests de plus haut niveau sont rarement des tests en boîte blanche
○ Les tests unitaires et les tests dʼintégration sont souvent des tests en boîte blanche.

● Les tests sont fortement couplés à lʼimplémentation :

○ Avantage : force les développeurs à bien réfléchir à leur code.
○ Désavantage : les tests doivent être modifiés si lʼimplémentation change.

Génie informatique et génie logiciel – LOG2440 A2024 19

 Semaine 6 – Validation et Vérification des logiciels

Tests en boîte blanche : exemple

Exemple dʼun bouton pause/play dʼune vidéo sur une page web
function playVideo(){
const video = [Link]('video');
if([Link])
[Link]();
else
[Link]();
}

[Link]('click',playVideo);

Tests en boîte blanche :

Test1 : < {Vidéo en pause, click} , { [Link]() a été appelée, [Link] === false } >
Test2 : < {Vidéo qui joue, click} , { [Link]() a été appelée, [Link] === true } >
Test3 : < {click}, { playVideo() a été appelée } >
Génie informatique et génie logiciel – LOG2440 A2024 20
 Semaine 6 – Validation et Vérification des logiciels

Comment bien tester

● Tester toutes les exigences.
○ Ex : tests de système et/ou dʼacceptation.
● Tester les "points de conception" : liens entre les modules, liens entre les classes, etc.
○ Ex : tests dʼintégration . Souvent les points faibles sont lors de lʼintégration de plusieurs éléments.
● Tester le code. Peut être fait avant (boîte noire) ou après (boîte blanche et boîte noire)
○ Ex : tests unitaires, tests de composantes, etc.
○ Tester les instructions du code (code coverage) et les branches du code (branch coverage)

● Avoir la mentalité de briser le projet durant la conception et exécution des tests

○ Contrairement au développement où nous avons la mentalité de faire fonctionner le projet
Génie informatique et génie logiciel – LOG2440 A2024 21
 Semaine 6 – Validation et Vérification des logiciels

Comment bien tester

● Le choix de lʼapproche de tests varie en fonction de la nature du projet. Par exemple :
○ TDD (Test Driven Development) ou BDD (Behaviour Driven Development)
■ On écrit les tests qui répondent aux requis et, ensuite, on écrit le code qui fait passer
ces tests. Ceci nous assure que le code qui est écrit est couvert par des tests.
■ Peu pratique si le code varie souvent ou les requis finaux ne sont pas très clairs.
○ Liste de contrôle (checklist) basé sur des erreurs du passé
■ Très pratique pour des projets similaires et répétitifs, mais nécessite une expertise.

● Le génie logiciel, cʼest choisir une approche acceptable selon le contexte du projet.

Génie informatique et génie logiciel – LOG2440 A2024 22

 Semaine 6 – Validation et Vérification des logiciels

Planification des tests

● Plus un défaut est détecté tard, plus le coût (temps, ressources, budget) est grand

● Un défaut dont le coût de réparation est trop grand peut être laissé dans le logiciel et
dégrader sa qualité. On appelle ceci la dette technique (technical debt).

● Important de penser aux tests avant de coder (planification) :

○ Écrire le code avec une idée comment le tester amène (souvent) une meilleure structure.
○ La mentalité des tests "briser le code" permet de prévoir les cas limites potentiels.

Génie informatique et génie logiciel – LOG2440 A2024 23

 Semaine 6 – Validation et Vérification des logiciels

Planification des tests : tests propres et tests sales

● Tests propres (clean tests) : devraient passer sans problème.
○ On vérifie le fonctionnement normal de ce quʼon teste
● Tests sales (dirty tests) : testent les valeurs limites qui pourraient provoquer des erreurs.
○ On essaie de briser le code avec des valeurs limites et/ou illogiques : division par 0, accès
à un index hors dʼun tableau, valeurs négatives, etc.
○ Très souvent, cʼest avec ce genre de tests quʼon trouve le plus de problèmes.
● Exemple : Test propres :
TP1 = < {5}, {1} >
const division = (i) => { TP2 = < {10}, {0.5} >
return 5/i; Tests sales :
} TS1 = < {0}, {Infinity} >
TS2 = < {“allo”}, {NaN} >
TS3 = < {“5”}, {1} >
Génie informatique et génie logiciel – LOG2440 A2024 24
 Semaine 6 – Validation et Vérification des logiciels

Planification des tests : métriques

● Important : mesure quantitative mais qui nʼest pas toujours une vérité absolue
○ Un test mal conçu peut avoir de très bonnes métriques sans vraiment être utile.

● Une métrique simple, mais efficace est la couverture du code (code coverage) :
○ 100% de couverture : il y a au moins 1 test qui a exécuté chaque ligne de code
■ Très difficile dans certains logiciels (code défensif, particularité du langage, etc.)
■ Couverture de 100% nʼest pas un garant dʼun code sans erreurs.

○ Divisé en 2 types : couverture des instructions et couverture des branches.

■ Les 2 types sont complémentaires et idéalement faits ensemble
Génie informatique et génie logiciel – LOG2440 A2024 25
 Semaine 6 – Validation et Vérification des logiciels

Couverture des instructions

[Link]("input-color").addEventListener("change", (event) => {
const newColor = [Link];
if ([Link](newColor)) { [Link](newColor); }
});

it("should call changeColor method of the Tool on a valid color change"

, () => {
const changeEventSpy = [Link]([Link], "changeColor")
.mockImplementation(() => { });
On vérifie si changerColor() a été appelée.
const input = [Link]("input-color");
1 test nécessaire pour couvrir toutes les instructions :
[Link] = "#00ff00";
[Link](new Event("change")); <{"#00ff00"}, { changeColor() appelée>

expect(changeEventSpy).toBeCalled();
});
Génie informatique et génie logiciel – LOG2440 A2024 26
 Semaine 6 – Validation et Vérification des logiciels

Couverture des branches

[Link]("input-color").addEventListener("change", (event) => {
const newColor = [Link];
if ([Link](newColor)) { [Link](newColor); }
});

it("should not call changeColor method of the Tool on an invalid color change"
, () => {
const changeEventSpy = [Link]([Link], "changeColor")
.mockImplementation(() => { });
const input = [Link]("input-color"); On vérifie si changerColor() a été appelée.
[Link] = "allo";
2 tests nécessaires pour couvrir toutes les branches :
[Link](new Event("change"));
expect(changeEventSpy).[Link](); <{"#00ff00"}, { changeColor() appelée>
}); <{"allo"}, { changeColor() pas appelée>
Question: est-ce des tests de boîte blanche ou boîte noire ?

Génie informatique et génie logiciel – LOG2440 A2024 27

 Semaine 6 – Validation et Vérification des logiciels

Planification des tests : valeurs possibles des entrées

● La complexité du nombre de cas de tests sʼapplique également pour les entrées.
● Dans une situation parfaite, on teste avec toutes les possibilités pour les entrées
○ Ceci devient très rapidement impossible dans certains cas
● Exemple dʼune méthode qui prend en entrée :
○ Nom : 20 caractères * 26 lettres = 2620
○ Adresse : 30 caractères * 26 lettres = 2630
○ Téléphone : 10 valeurs * 10 chiffres = 1010
○ Total = 2620*2630*1010 ≈ 1080 possibilités (plus que le nombre dʼatomes dans lʼunivers)

Génie informatique et génie logiciel – LOG2440 A2024 28

 Semaine 6 – Validation et Vérification des logiciels

Classes dʼéquivalences
● Regroupement des valeurs dans des classes dʼéquivalences :
○ Ensemble de valeurs dont chaque élément est considéré équivalent dans une relation.
○ Tous les éléments de la classe se comportent de la même manière pour une condition.
○ Ex : if (x > 0 && x <= 4), lʼensemble [1, 2, 3, 4] est une classe dʼéquivalence

● Les classes dʼéquivalences permettent de réduire le nombre de tests redondants.

○ Ne pas oublier les tests sales : les valeurs limites et les valeurs invalides sont d'excellents
candidats pour détecter des défauts.

Génie informatique et génie logiciel – LOG2440 A2024 29

 Semaine 6 – Validation et Vérification des logiciels

Outils de tests
● Utilisation dʼoutils ou librairies de tests pour automatiser le processus.
○ Peuvent aider avec différents types de tests, mais on se concentre sur les
tests unitaires et les tests de bout en bout (e2e) en LOG2440.

● Les différents langages programmation ont plusieurs librairies disponibles :

○ CppUnit/Catch2 (C++), pytest (Python), JUnit (Java), NUnit (C#), etc.
○ Le JavaScript également : Mocha, Jasmine, Jest et beaucoup dʼautres.

● Syntaxe variable, mais fonctionnement similaire :

○ Si vous en connaissez un, il est relativement facile de passer à un autre.
Génie informatique et génie logiciel – LOG2440 A2024 30
 Semaine 6 – Validation et Vérification des logiciels

Outils de tests - Jest

● Librairie de tests très populaire pour le JavaScript.
○ Utilisé surtout pour des tests unitaires, mais peut couvrir dʼautres types de tests.
○ Nécessite une configuration minimale par rapport à dʼautres outils similaires
○ Le support dʼESM est encore expérimental : Jest utilise surtout la syntaxe CommonJS

● Quelques termes à retenir :

○ Suite : un ensemble de tests qui impliquent du code commun. En Jest : describe
○ Validateur : fonction qui valide le résultat dʼun test. En Jest, cʼest la fonction expect
○ Comparateur : fonction qui permet de tester des valeurs à valider.

Génie informatique et génie logiciel – LOG2440 A2024 31

 Semaine 6 – Validation et Vérification des logiciels

Jest - Exemple de base

function anagram(firstSequence, secondSequence) {
if ([Link] !== [Link]) {
return false;
}

const sortedFirstSequence = [Link](firstSequence).sort().toString();

const sortedSecondSequence = [Link](secondSequence).sort().toString();
return sortedFirstSequence === sortedSecondSequence;
}

[Link] = anagram;

Génie informatique et génie logiciel – LOG2440 A2024 32

 Semaine 6 – Validation et Vérification des logiciels

Jest - Exemple de base

const anagram = require("./anagram");

describe("Anagram tests", () => { Suite de tests

test("anagram function exists", () => { expect(typeof anagram).toEqual("function"); }); Test unitaire

test("should return True if two empty strings are given as input"

, () => {
const result = anagram("", "");
expect(result).toEqual(true); Validateur
});

test("should return False if first input is longer than second one"

, () => {
const result = anagram("MAISON", "CHAT");
expect(result).toEqual(false); Comparateurs
});

test('"cinema" should be be an anagram of "iceman"'

, () => { expect(anagram("cinema", "iceman")).toBeTruthy(); });
test('"Hello" should NOT be an anagram of "Aloha"'
, () => { expect(anagram("Hello", "Aloha")).toBeFalsy(); });
test('"Hello" should be an anagram of itself'
, () => { expect(anagram("Hello", "Hello")).toBeTruthy(); });
});

Génie informatique et génie logiciel – LOG2440 A2024 33

 Semaine 6 – Validation et Vérification des logiciels

Jest : tests et couverture du code

Résultat de la commande npm run coverage

Le résultat est également disponible en format HTML

npm run test exécute les tests sans calculer la couverture

Génie informatique et génie logiciel – LOG2440 A2024 34
 Semaine 6 – Validation et Vérification des logiciels

Jest - Réusiner (refactor) à lʼaide des tests

function Anagram() {
function sortString(s) {
return [Link](s).sort().toString();
}

return function anagram(firstSequence, secondSequence) {

return sortString(firstSequence) === sortString(secondSequence);
};
} Si le code est bien fait, les tests devraient tous passer

Ceci est un exemple de tests de régression.

const anagram = Anagram();
[Link] = anagram;

Génie informatique et génie logiciel – LOG2440 A2024 35

 Semaine 6 – Validation et Vérification des logiciels

Jest - Exercice
● Est-ce que le programme est sensible à la case ?
○ Comment le détecter ?
○ Si oui, comment modifier ce comportement ?
● Est-ce que le programme gère le cas dʼun paramètre null ou undefined ?
○ Comment le détecter ?
○ Si non, comment gérer ces cas ?

Génie informatique et génie logiciel – LOG2440 A2024 36

 Semaine 6 – Validation et Vérification des logiciels

Jest - Exemple récapitulatif (PolyPaint)

Tool

DOM PolyPaint Pencil

loadCanvas()

Code source sur GitHub

Génie informatique et génie logiciel – LOG2440 A2024 37

 Semaine 6 – Validation et Vérification des logiciels

Échafaudage (Scaffolding)
● Structure autour de lʼunité à tester
○ Lʼunité a besoin dʼun environnement et certains éléments pour être testée adéquatement.
● Crée que les éléments nécessaires et, au besoin, les détruit à la fin des tests.
○ Lʼéchafaudage est construit avant et détruit après chaque test ou chaque suite de tests

● Les dépendances de lʼunité sont remplacées par des Stub ou des Mock
○ Le Stub permet dʼéliminer des défauts provenant de la dépendance remplacée
○ Le Mock permet de simuler un comportement quelconque du système
○ Note : Les tests dʼintégrations nécessitent des vraies dépendances et comportements

Génie informatique et génie logiciel – LOG2440 A2024 38

 Semaine 6 – Validation et Vérification des logiciels

Jest - Échafaudage
export default function loadCanvas() { describe("Canvas-loader tests", () => {
const baseCanvas = document let canvas;
let context;
.getElementById("base-canvas");
const context = baseCanvas
const clearHTML = () => ([Link] = "");
? [Link]("2d")
: null; beforeEach(() => {
Construction avant chaque test
return { canvas = [Link]("canvas");
canvas: baseCanvas, [Link]("id", "base-canvas");
context: context, [Link](canvas);
context = [Link]("2d");
};
});
}

afterEach(() => {
clearHTML(); Nettoyage après chaque test
});
Génie informatique et génie logiciel – LOG2440 A2024 39
 Semaine 6 – Validation et Vérification des logiciels

Jest - Exécution des tests

it("loadCanvas should load the correct canvas and its context", () => {
const loadData = loadCanvas();
expect([Link]).toEqual(canvas);
expect([Link]).toEqual(context);
});

it("loadCanvas should return null if the canvas has a wrong id", () => {
clearHTML(); Propre à ce test

const wrongCanvas = [Link]("canvas");

[Link]("id", "wrong-canvas");
[Link](wrongCanvas);
const loadData = loadCanvas();
expect([Link]).toBeNull();
expect([Link]).toBeNull();
});

Génie informatique et génie logiciel – LOG2440 A2024 40

 Semaine 6 – Validation et Vérification des logiciels

Jest - Stub Seulement les méthodes nécessaires

pour la dépendance

export default class PolyPaint { beforeEach (() => {

toolStub = {
constructor(canvas, tools) { name: "toolStub" ,
[Link] = canvas; Dépendances onMouseDown : () => {},
onMouseMove : () => {},
[Link] = tools;
onMouseUp : () => {},
[Link] = tools[0]; changeWidth : () => {},

} changeColor : () => {},

};
} const canvas = [Link] ("canvas");
[Link] ("id", "base-canvas" );
[Link] (canvas);

polyPaint = new PolyPaint (canvas, [toolStub]);

});

Génie informatique et génie logiciel – LOG2440 A2024 41

 Semaine 6 – Validation et Vérification des logiciels

Espion (Spy)
● Parfois intéressant de savoir plus sur une fonction impliquée dans les tests
○ Si elle a été appelée ou non, avec quels paramètres, combien de fois, etc.
○ Fait grâce à un espion (spy) attaché autour de la fonction/objet
● Contexte qui détecte lʼappel, les paramètres dʼentrées et les valeurs de sorties de la fonction.

● Peut capturer lʼappel à la fonction et le rediriger :

○ Utile si on veut savoir si la fonction a été appelée ou non, mais sans lʼexécuter réellement.
○ Utile si on veut éliminer les dépendances entre fonctions ou objets
○ Mock : similaire au Stub, mais avec un comportement modifié de lʼorigine

Génie informatique et génie logiciel – LOG2440 A2024 42

 Semaine 6 – Validation et Vérification des logiciels

Jest - Spy Mock le comportement de la

fonction externe
describe("Mouse Events", () => {
it("should call onMouseDown method of the Tool on a mouse down event", () => {
const mouseEventSpy = [Link]([Link], "onMouseDown").mockImplementation(() => {});
[Link](new MouseEvent("mousedown"));
expect(mouseEventSpy).toBeCalled();
});

it("should call onMouseUp method of the Tool on a mouse up event", () => {

const mouseEventSpy = [Link]([Link], "onMouseUp").mockImplementation(() => {});
[Link](new MouseEvent("mouseup"));
expect(mouseEventSpy).toBeCalled();
});

Génie informatique et génie logiciel – LOG2440 A2024 43

 Semaine 6 – Validation et Vérification des logiciels

Jest - Spy avec des dépendances internes

updateCurrentPoint(event) {
const coord = [Link](event); Élimination de la dépendance à
[Link]([Link], [Link], coord); l’intérieur d’une classe
[Link] = coord;
}

it("updateCurrentPoint() should call getPositionFromMouse and draw", () => {

const getPositionSpy = [Link](pencil, "getPositionFromMouse").mockImplementation(() => {});
const drawSpy = [Link](pencil, "draw").mockImplementation(() => {});

[Link](mousePosition);
expect(getPositionSpy).toBeCalled();
expect(drawSpy).toBeCalled();
});

Génie informatique et génie logiciel – LOG2440 A2024 44

 Semaine 6 – Validation et Vérification des logiciels

Jest - Spy qui modifie les valeurs de retour

it("updateCurrentPoint() should set lastPoint to new coordinate" , () => {
const newMouseStub = { offsetX: 100, offsetY: 100 };
// Enlever la dépendance à getPositionFromMouse
[Link](pencil, "getPositionFromMouse" ).mockImplementation (() => {
return { x: newMouseStub .offsetX, y: newMouseStub .offsetY };
});
// Ne pas appeler la vraie méthode draw()
const drawSpy = [Link](pencil, "draw").mockImplementation (() => {});

const newMousePosition = { x: 100, y: 100 };

[Link] (newMouseStub );
expect([Link]).toEqual(newMousePosition );
});

Génie informatique et génie logiciel – LOG2440 A2024 45