Les tests dans DevOps

Bureau E204

© 2023-2024 – Module DevOps – Les tests dans DevOps 1

 Plan du cours

• Introduction
• Quelques types de tests
• Les tests dans le pipeline CI/CD
• Test unitaire
• Travail à faire

© 2023-2024 – Module DevOps – Les tests dans DevOps 2

 Introduction

Quelle est la composition de base d’une équipe

Scrum ?

© 2023-2024 – Module DevOps – Les tests dans DevOps 3

 Introduction

Le développeur

Ingénieur qualité

© 2023-2024 – Module DevOps – Les tests dans DevOps 4

 Introduction

o Le rôle de l’ingénieur qualité (test) est de surveiller la qualité du

projet au cours des différentes itérations de la réalisation.
o Pour être efficace, les ingénieurs Qualité doivent communiquer
avec les membres de l'équipe.
o Ils doivent les convaincre de l'importance de respecter les
procédures de correction afin que les produits proposés
répondent aux recommandations du client.
o L'acquisition d'autres compétences est essentielle pour
l’évolution professionnelle d’un ingénieur qualité.

© 2023-2024 – Module DevOps – Les tests dans DevOps 5

 Introduction

Rôle d’un testeur

© 2023-2024 – Module DevOps – Les tests dans DevOps 6
 Quelques types de test

• Il existe différents niveaux de test :

– Test d’intégration
– Test de régression
– Test de montée en charge
– Test de sécurité
– Test unitaire
– ….

© 2023-2024 – Module DevOps – Les tests dans DevOps 7

 Quelques types de test : Test d’intégration

• L'intégration, c'est assembler plusieurs composants logiciels

élémentaires pour réaliser un composant de plus haut
niveau.
Exemple: Une classe Client et une classe Produit pour créer
un module de commande sur un site marchant, c'est de
l'intégration !
• Un test d'intégration vise à s'assurer du bon fonctionnement
de la mise en œuvre conjointe de plusieurs unités de
programme, testés unitairement au préalable.

© 2023-2024 – Module DevOps – Les tests dans DevOps 8

 Quelques types de test : Test de regression

• Les tests de régression sont les tests exécutés sur un

programme préalablement testé mais qui a subit une
ou plusieurs modifications.

© 2023-2024 – Module DevOps – Les tests dans DevOps 9

Quelques types de test : Test de montée en charge

• Test de montée en charge (Test de capacité ) : il s'agit

d'un test au cours duquel on va simuler un nombre
d'utilisateurs sans cesse croissant de manière à déterminer
quelle charge limite le système est capable de supporter.

© 2023-2024 – Module DevOps – Les tests dans DevOps 10

 Quelques types de test : Test de sécurité

• Le test de sécurité est un type de test de logiciel qui vise à

découvrir les vulnérabilités du système et à déterminer que
ses données et ressources sont protégées contre
d'éventuels intrus.

© 2023-2024 – Module DevOps – Les tests dans DevOps 11

 Les tests dans le pipeline CI/CD

Intégration continue
• Dans une chaine d’intégration DevOps, il est primordiale de
définir et de sélectionner les tests qui y seront incluses sans pour
autant rendre le déploiement lent.
• Pour la phase d’intégration continue, il est recommandé d’avoir
au moins les tests unitaires et les tests du qualité des codes.
• N’étant pas un développeur, le rôle de l’ingénieur qualité dans
cette phase est d’automatiser la génération de rapports
détaillés pour les développeurs.

© 2023-2024 – Module DevOps – Les tests dans DevOps 12

 Les tests dans le pipeline CI/CD

Livraison continue
• Les tests unitaires sont utiles dans la phase d’intégration continue mais
avoir des bouts de code testés à part n’est pas suffisant pour la phase
de livraison continue.
• Il faut impérativement inclure des tests beaucoup plus avancés (test
d’intégration, etc..) même si le process prendra beaucoup plus de
temps.
• Le rôle de l’ingénieur qualité est beaucoup plus important dans cette
phase (optimiser le temps d’exécution, assurer l’automatisation des
différents tests, vérification des différents environnements).

© 2023-2024 – Module DevOps – Les tests dans DevOps 13

 Les tests dans le pipeline CI/CD

Déploiement continu

• L’environnement de production étant très sensible, des tests

beaucoup plus avancés sont nécessaires dans un environnement
identique à celui de production ( environnement staging).

• Le test fonctionnel vérifiant que la partie IHM ne contient pas de

bugs. Selenium est l’outil le plus recommandé pour ce genre de
tests.

• Les UAT (User acceptance test) faites par les business analyst
consolide les tests initialement faits.

© 2023-2024 – Module DevOps – Les tests dans DevOps 14

 Les tests dans le pipeline CI/CD

Déploiement continu

• Les tests non fonctionnels ( tests de performance (Jmeter, etc..)

génèrent des métriques très intéressantes pour améliorer la qualité
du livrable.

• Les tests de sécurité (Fortify, etc..)détectent des failles de sécurité.

• L’objectif du testeur dans cette phase est de minimiser la batterie

de test tout en assurant les mêmes performances et de
sélectionner les outils de test les plus performants.

© 2023-2024 – Module DevOps – Les tests dans DevOps 15

 Les tests dans le pipeline CI/CD

• Nous constatons donc que les tests sont présents dans tous les
process DevOps.
• Les tests les plus rapides (temps d’exécution réduit) sont présents
au début du pipeline (rythme d’intégration continu très
important). Le retour de ces tests améliore considérablement la
productivité.
• Les tests nécessitant beaucoup plus de temps d’exécution
arrivent beaucoup plus tard dans le pipeline(Livraison ou
déploiement continue).

© 2023-2024 – Module DevOps – Les tests dans DevOps 16

 Les tests dans le pipeline CI/CD

• Le choix d’exécution des tests est fortement lié à la pyramide

de tests.

Automate as Many Tests as You Can !

© 2023-2024 – Module DevOps – Les tests dans DevOps 17

 Tests manuelles vs tests automatiques

• Les tests manuelles sont assez fastidieuses et répétitives.

• Vu la monotonie des taches, l’ingénieur qualité peut manquer

de rigueur et engendrer la non-détection de quelques bugs.

• Les tests automatiques peuvent être réalisés en parallèle si les

capacités de la machine le permettent.

• Les tests automatiques nécessitent un certain temps de mise en

place. Ce temps est facilement récupéré lors des prochaines
itérations surtout avec le rythme de livraison continu assez
rapide.

© 2023-2024 – Module DevOps – Les tests dans DevOps 18

 Test unitaire

• Dans notre cours, on va s’intéresser aux tests unitaires.

© 2023-2024 – Module DevOps – Les tests dans DevOps 19

 Test unitaire : Définition

• C’est un type de test logiciel dans lequel une seule unité ou un

seul composant de logiciel est testé. L'objectif est de vérifier que
chaque unité de code logiciel fonctionne comme prévu. Les
unités peuvent être des fonctions, des méthodes, des
procédures, des modules ou des objets individuels.

• Dans des différents cycles de développement, les tests unitaires

sont le premier niveau de test effectué avant les tests
d'intégration.

© 2023-2024 – Module DevOps – Les tests dans DevOps 20

 Test unitaire : Définition

• Les tests unitaires sont une technique de test en boîte blanche,

généralement effectuée par des développeurs. Cependant,
dans le monde réel, les ingénieurs QA (Quality Assurance)
effectuent également des tests unitaires.

• Une bonne couverture de tests permet d’être sûr que les

fonctionnalités développées fonctionnent bien avant la
livraison, mais aussi de vérifier que le code développé sur une
version précédente s’exécute toujours correctement sur la
version courante.

© 2023-2024 – Module DevOps – Les tests dans DevOps 21

 Test unitaire : Les phases

• Le test unitaire comporte 3 phases:

– D'abord, il initialise une petite partie de l'application à tester.

– Ensuite, il applique ensuite un stimulus au système à tester

(généralement en appelant une méthode)

– Enfin, il observe le comportement résultant.

Si le comportement observé est celui attendu, le test unitaire réussit,

sinon il échoue, indiquant un problème quelque part dans le système
testé.

→ Ces trois phases de tests unitaires sont également appelées

Arrange, Act et Assert, ou AAA en abrégé.
© 2023-2024 – Module DevOps – Les tests dans DevOps 22
 Test unitaire : Avantage et intérêt

• Garantie la non régression

• Détection de bug plus facile
• Aide a isoler les fonctions
• Aide a voir l’avancement d’un projet (TDD*)

– Le test-driven development (TDD) ou en français le développement piloté par les tests est une
technique de développement de logiciel qui préconise d'écrire les tests unitaires avant d'écrire le
code source d'un logiciel.
• Les étapes de TDD:

1. Écrire un test échoué

2. Écrire le code le plus simple pour que le test soit réussi
3. Supprimer la duplication (code/test) et améliorer la lisibilité (Refactor)
→ Le TDD est une approche avec laquelle on cherche à cadrer la production
de code par petits incréments qui sont testés.

© 2023-2024 – Module DevOps – Les tests dans DevOps 23

Test unitaire : Outils

Karma

Cantata

© 2023-2024 – Module DevOps – Les tests dans DevOps 24

 Test unitaire : Résultats

• Un test unitaire peut renvoyer 3 résultats différents :

– Success : test réussi

– Error : erreur inattendue à l’exécution (Exception)

– Failure : au moins une assertion est fausse

© 2023-2024 – Module DevOps – Les tests dans DevOps 25

 Test unitaire: JUnit - Définition

• JUnit est un framework open source pour le développement et

l'exécution de tests unitaires automatisables. Le principal intérêt est de
s'assurer que le code répond toujours aux besoins même après
d'éventuelles modifications.

• Il n'y a pas de limite au nombre de tests au sein de notre classe de test.

• On écrit au moins un test par méthode de la classe testée.
• Pour désigner une méthode comme un test, il suffit d’utiliser l'annotation
@Test (à partir de JUnit4).

© 2023-2024 – Module DevOps – Les tests dans DevOps 26

 Test unitaire: JUnit - Dépendance

• Dans le fichier « pom.xml », nous pouvons voir la dépendance starter

suivante qui inclut les bibliothèques pour tester les applications Spring
Boot.

© 2023-2024 – Module DevOps – Les tests dans DevOps 27

 Test unitaire: JUnit – Mise en place

• Pour mieux comprendre l’implémentation des tests unitaires avec JUnit

afin de tester les méthodes unitairement, nous allons implémenter une
petite application de gestion de la facturation d’une boutique
• Le diagramme des classes de notre application est le suivant :

© 2023-2024 – Module DevOps – Les tests dans DevOps 28

 Test unitaire: JUnit – Mise en place
• En ce qui concerne l’implémentation des méthodes de test, le projet
Spring Boot génère automatiquement un exemple de classe de test
dans le package src/test/java (le package qui qui va contenir toutes
les classes des tests unitaires). Nous allons maintenant créer nos propres
classes de test en suivant les bonnes pratiques et supprimer cette classe
par défaut.

© 2023-2024 – Module DevOps – Les tests dans DevOps 29

 Test unitaire: JUnit – Mise en place
• La structure de notre projet est la suivante :

Tests unitaires
avec Junit et
Mockito

© 2023-2024 – Module DevOps – Les tests dans DevOps 30

 Test unitaire: JUnit – Mise en place
• En suivant les bonnes pratiques de développement, nous devons créer
une classe de test pour chaque classe service. Nous avons ainsi créer la
classe de test ClientServiceImplTest pour la classe service
ClientServiceImpl et la classe FactureServiceImplTest pour la classe
FactureServiceImpl

• Pour créer une classe de test, on crée une classe avec le même nom
que la classe service en ajoutant le mot Test à la fin.
• Pour créer une méthode de test, on crée une méthode en gardant le
même nom de la méthode en la précédant avec le mot test
• exemple : ajouterFacture (Facture f) => testAjouterFacture(Facture f)

© 2023-2024 – Module DevOps – Les tests dans DevOps 31

 Test unitaire: JUnit – Mise en place

• Les annotations à ajouter à la classe de test sont les suivantes :

@ExtendWith : pour indiquer que nous allons travailler avec des tests
unitaires en utilisant JUnit

@TestMethodOrder : pour pouvoir ordonner le lancement des tests selon

une logique bien précise

@SpringBootTest : pour indiquer qu’il s’agit d’une classe de test

© 2023-2024 – Module DevOps – Les tests dans DevOps 32

 Test unitaire: JUnit – Mise en place

Les annotations que nous pouvons utiliser dans JUnit 5 sont les suivantes :

• @Test : C’est comme dans JUnit4, cette annotation est utilisée pour

dire que c’est une méthode de test.

• @Order : Pour imposer l'exécution des tests dans un ordre spécifique

(Pour pouvoir utiliser cette annotation, on doit ajouter

@TestMethodOrder(MethodOrderer.OrderAnnotation.class) au-dessus

de la classe de test)

• @RepeatedTest (n) : La méthode annotée sera exécutée n fois comme

si le même test avait été écrit n fois.

© 2023-2024 – Module DevOps – Les tests dans DevOps 33

 Test unitaire: JUnit – Mise en place

• @BeforeEach @AfterEach : Méthodes qui sont exécutées avant et

après chaque méthode de test dans la classe.

• @BeforeAll @AfterAll : Ces annotations sont utilisées pour signaler que

les méthodes statiques annotées doivent être exécutée avant et après

tous les tests @Test

© 2023-2024 – Module DevOps – Les tests dans DevOps 34

 Test unitaire: JUnit – Mise en place

Les assertions :
Lorsqu’on implémente les tests unitaires, nous pouvons utiliser les

assertions. Ce sont des méthodes utilitaires dont le résultat de l'expression

booléenne indique un succès ou une erreur pour supporter l'assertion de

conditions dans les tests. Ces méthodes sont accessibles à travers la classe

Assertions, dans JUnit 5.

Afin d'augmenter la lisibilité du test et des assertions elles-mêmes, il est

toujours recommandé d'importer statiquement la classe respective. De

cette façon, nous pouvons nous référer directement à la méthode

d'assertion elle-même sans la classe représentative comme préfixe.

© 2023-2024 – Module DevOps – Les tests dans DevOps 35
 Test unitaire: JUnit – Mise en place

Quelques assertions disponibles :

Assertions Actions Implémentation

Vérifier l’égalité entre deux

assertArrayEquals assertArrayEquals (valeur attendue, valeur à tester);
tableaux
Vérifier l’égalité entre deux
assertEquals entiers, réels, chaines de assertEquals ("Test unitaire", "Test unitaire");
caractères, …
Vérifier l’inégalité entre deux
assertNotEquals entiers, réels, chaines de assertEquals ("Test unitaire", "test unitaire");
caractères, …
Vérifier que les conditions
assertTrue assertTrue (5 > 4)
fournies sont vraies
Vérifier que les conditions
assertFalse assertFalse(5 > 6)
fournies sont fausses

Vérifier l’égalité entre deux

assertSame assertSame(new Client(), new Client())
objets.

© 2023-2024 – Module DevOps – Les tests dans DevOps 36

 Test unitaire: JUnit – Mise en place

Assertions Actions Implémentation

Vérifier l’inégalité entre deux

assertNotSame assertNotSame(new Client(), new Magasin())
objets.

Vérifier l’égalité entre deux

assertArrayEquals assertArrayEquals(int[] expected, int[] actual)
tableaux

assertAll( "heading",
() -> assertEquals(4, 2 * 2),
Permet la création d'assertions
assertAll () -> assertEquals("java","JAVA".toLowerCase()),
groupées
() -> assertEquals(null, null)
);

Affirmer que l'exécution d'un assertTimeout( ofSeconds(2), () -> { //

assertTimeout exécutable fourni se termine avant code necéssite maximum 2 minutes pour
une date donnée. s’exécuter Thread.sleep(1000); } );

© 2023-2024 – Module DevOps – Les tests dans DevOps 37

 Test unitaire: JUnit – Mise en place
Nous allons maintenant implémenter à titre d’exemple deux
méthodes de test :
Commençons par la première méthode de test
de l’ajout d’un client.
ce test permet de vérifier que le nom et le prénom du client ont
une taille logique ainsi que la tranche d’âge (calculable) est bien
associé à son âge en respectant les conditions suivantes :
si age < 10 : ENFANT sinon si age entre 10 et 19 : ADOLESCENT
sinon (age supérieur à 19) ADULTE
Nous vérifions aussi que le client a bien été ajouté à la table Client.
© 2023-2024 – Module DevOps – Les tests dans DevOps 38
 Test unitaire: JUnit – Mise en place

Le code de notre méthode service est le suivant. La méthode

currentAgeAffectation associe le client à sa tranche d'âge selon le retour de la

méthode calculateAge

© 2023-2024 – Module DevOps – Les tests dans DevOps 39

 Test unitaire: JUnit – Mise en place
La méthode de test associée est présentée ainsi avec les commentaires explicatifs

© 2023-2024 – Module DevOps – Les tests dans DevOps 40

 Test unitaire: JUnit – Mise en place

Passons maintenant au deuxième test unitaire d’ajout d’une facture

Le test de l'ajout facture consiste à vérifier que le total de chaque

détail facture ainsi que le total ht remisé de la facture soit bien

calculé en prenant en considération le prix du produit, la quantité

et le pourcentage de la remise. Nous vérifions aussi que la facture

et ses détails sont bien insérés dans la base de données.

NB : prix ht remisé = prix ht - remise

© 2023-2024 – Module DevOps – Les tests dans DevOps 41

 Test unitaire: JUnit – Mise en place
Les données que nous allons utiliser dans ce test sont les suivantes :
Client : ahmed slimi né le 01-05-2000
Produits : produit 1 dentifrise code 05 prix : 25 dt
produit 2 pèse personne code 19 prix 250 dt
La facture contient les deux détails suivants pour une remise globale
de 10%, un prix ht de 300 dinars et un prix ht remisé égale à 270 dt :
Detail Facture 1 : dentifrice quantité : 2 prix total : 50 dt
Detail Facture 2 : pèse personne quantité : 1 prix total : 250 dt
Nous assertons dans notre scénario principal de test que le total
facture remisé ht est égal à 250+50 –30 (remise) =270 dt
© 2023-2024 – Module DevOps – Les tests dans DevOps 42
 Test unitaire: JUnit – Mise en place
La méthode service de l’ajout de la facture est la suivante :

© 2023-2024 – Module DevOps – Les tests dans DevOps 43

Test unitaire: JUnit – Mise en place

© 2023-2024 – Module DevOps – Les tests dans DevOps 44

 Test unitaire: JUnit – Mise en place
La méthode de test associée au service de l’ajout de la facture expliquée est la suivante :

© 2023-2024 – Module DevOps – Les tests dans DevOps 45

Test unitaire: JUnit – Mise en place

© 2023-2024 – Module DevOps – Les tests dans DevOps 46

Test unitaire: JUnit – Mise en place

© 2023-2024 – Module DevOps – Les tests dans DevOps 47

 Test unitaire: JUnit – Bonnes pratiques

Pour réaliser un test unitaire réussi, il y a un ensemble de bonnes

pratiques à respecter :

- En cas d’ajout de nouvelles lignes, il faut vérifier à la fois

l’existence de cette nouvelle ligne (id existant) et que les champs

insérés sont pertinents et le scénario métier est bien réalisé

- L’état de la base de données doit être le même avant et après

l’exécution des différents tests unitaires (chaque ligne ajouté

dans un test doit être éliminé après)

- Le scénario de test doit être logique et complet

© 2023-2024 – Module DevOps – Les tests dans DevOps 48

 Test unitaire: Mockito – Mise en place
Mockito :
Les tests unitaires doivent être de petits tests, légers et rapides.
Cependant, l'objet testé peut avoir des dépendances sur d'autres objets.
Il peut avoir besoin d'interagir avec une base de données, de
communiquer avec un service Web.
Dans la réalité, tous ces services ne sont pas disponibles pendant les tests
unitaires. Même s'ils sont disponibles, les tests unitaires de l'objet testé et de
ses dépendances peuvent prendre beaucoup de temps. Que faire si ?
o Le service web n'est pas joignable.
o La base de données est en panne pour maintenance.
o La file d'attente des messages est lourde et lente.

© 2023-2024 – Module DevOps – Les tests dans DevOps 49

 Test unitaire: Mockito – Mise en place

Tout cela va à l'encontre de l'objectif des tests unitaires qui sont

atomiques, légers et rapides.

Nous voulons que les tests unitaires s'exécutent en quelques millisecondes.

Si les tests unitaires sont lents, les constructions deviennent lentes, ce qui

affecte la productivité de l’équipe de développement.

La solution consiste à utiliser le mocking, un moyen de fournir des doubles

de test pour vos classes à tester.

© 2023-2024 – Module DevOps – Les tests dans DevOps 50

 Test unitaire: Mockito – Mise en place
Pour simplifier le mock, on peut la considérer comme un bouchon qui va

isoler la classe à tester unitairement comme décrit dans la figure ci-

dessous :

© 2023-2024 – Module DevOps – Les tests dans DevOps 51

 Test unitaire: Mockito - Dépendance

• Dans le fichier « pom.xml », nous devons ajouter la dépendance

suivante :

© 2023-2024 – Module DevOps – Les tests dans DevOps 52

 Test unitaire: Mockito – Mise en place

Pour pouvoir utiliser le mock, il suffit d’ajouter au niveau de la classe de

test :

Dans notre cas, nous allons travailler sur les mêmes méthodes (ajout

facture, ajout client) sans persister les données dans la base de données

(données mock)

© 2023-2024 – Module DevOps – Les tests dans DevOps 53

 Test unitaire: Mockito – Mise en place
La première méthode qui teste l’ajout du client suit la même logique que

le test avec JUnit sans accès à la base de données

© 2023-2024 – Module DevOps – Les tests dans DevOps 54

 Test unitaire: Mockito – Mise en place
La deuxième méthode de test de l’ajout facture est la suivante :

© 2023-2024 – Module DevOps – Les tests dans DevOps 55

Test unitaire: Mockito – Mise en place

© 2023-2024 – Module DevOps – Les tests dans DevOps 56

 Test unitaire: Mockito – Mise en place

Les méthodes « when » et « thenReturn » de Mockito permettent de

paramétrer le mock en affirmant que si la méthode findById() est appelée

sur la classe (mockée) « FactureRepository », alors on retourne l’objet «m»

comme résultat .

C'est grâce à cette ligne que l'on isole bien le test du service. Aucun

échec de test ne peut venir de « FactureRepository », car on le simule, et

on indique comment simuler.

© 2023-2024 – Module DevOps – Les tests dans DevOps 57

 Test unitaire: Mockito – Mise en place

On peut aussi vérifier, si on utilise la méthode verify() de Mockito, que la

classe (mockée) « FactureRepository » a été utilisée, en particulier la

méthode « save() ».

Vérifier que la méthode save du

FactureRepository a été appelée

© 2023-2024 – Module DevOps – Les tests dans DevOps 58

 Test unitaire: Résumé

• La phase de tests unitaire c’est une phase primordiale dans la

réalisation d’un projet.

• Un mock est un type de doublure de test simple à créer, et qui vous

permet également de tester comment on interagit avec lui.

• Mockito vous permet de définir comment vos mocks doivent se

comporter (avec when) et vérifier si ces mocks sont bien utilisés (avec
verify).

© 2023-2024 – Module DevOps – Les tests dans DevOps 59

 Travail à faire

• Pour chaque module du projet, réaliser quelques tests unitaires avec

JUnit et mockito et ajouter un nouveau « Stage » dans Jenkins pour
lancer les tests unitaires automatiquement.

• Les tests doivent etre consistants et ne doivent pas traiter un simple crud

© 2023-2024 – Module DevOps – Les tests dans DevOps 60

 Les tests dans DevOps

Si vous avez des questions, n’hésitez pas à

nous contacter :

Département Informatique
UP ASI

Bureau E204

© 2023-2024 – Module DevOps – Les tests dans DevOps 61

Les tests dans DevOps

© 2023-2024 – Module DevOps – Les tests dans DevOps 62