Résumé Management de qualité

I- Généralités :
La qualité du logiciel est une notion multiforme qui
recouvre :
– la validité : Réaliser exactement les tâches définies.

– la fiabilité : Assurer de manière continue le service attendu

– la robustesse : Fonctionner même dans des conditions

anormales

– l’extensibilité : Facilité d'adaptation d'un logiciel aux

changements

– la réutilisabilité : Aptitude à être réutilisé en tout ou partie

– la compatibilité : Pouvoir être combinés les uns aux autres.

– l’efficience : Utiliser les ressources matérielles telles la

mémoire, la puissance de l’U.C., etc.

– la portabilité : Facilité à être porté sur de nouveaux

environnements matériels et/ou logiciels

– la traçabilité : Capacité à identifier et/ou suivre un élément

du cahier de charges lié à un composant d'un logiciel.

– la vérifiabilité : Facilité de préparation des procédures de

recette et de certification

– l’intégrité : Protéger ses différents composants conte des

accès ou de modifications non autorisés
Déf. ISO (Organisation internationale de normalisation) :
Ensemble des traits et des caractéristiques d’un produit logiciel
portant sur son aptitude à satisfaire des besoins exprimés ou
implicites

Déf. IEEE : La qualité du logiciel correspond au degré selon

lequel un logiciel possède une combinaison d’attributs désirés.

ISO/IEC 25010 conçue pour aider les organisations à définir,

évaluer et gérer la qualité des logiciels tout au long de leur
cycle de vie, de la conception à la maintenance.

II- Principes SOLID

- Responsabilité unique (Single Responsability): Une classe
n'a qu'une responsabilité et ne doit avoir qu'une raison de
changer.
- Ouverture/fermeture (Open/Closed) : Une classe doit être
ouverte aux extensions (ajouts) mais fermée aux
modifications (du code existant).
Pour les classes, l’héritage est le mécanisme essentiel pour la
mise en œuvre du principe, avec deux approches possibles :
l’héritage d’implantation et l’héritage d’abstraction.
- Substitution de Liskov (Liskov substitution) :
« Un instance d'une classe doit pouvoir être substituée sans
modification par une instance d'une sous-classe » (et sans que
le programme ne soit altéré dans son comportement)
Autrement dit :
Si une classe B hérite d’une classe A, tout programme écrit pour
traiter des instances de A doit pouvoir traiter des instances de
B sans même savoir que ce ne sont pas des instances directes
de A.
NB : Lorsqu’on fait l’héritage on ne doit pas affaiblir ou
renforcer des conditions !
- Séparation des interfaces (Interfaces Segregation) : Un
client ne doit jamais être force de dépendre d'une interface
qu'il n'utilise pas.
Éviter d’utiliser « une grosse interface » avec beaucoup de
méthodes pas toujours utiles pour tous les utilisateurs de
cette interface et scinder ces « grosses interfaces » en
interfaces plus spécialisées et plus cohérentes.
Si une classe implémente une interface alors elle doit
redéfinir toutes ses méthodes (éventuellement vides avec {})
- Inversion des dépendances (Dependency inversion) : Les
modules (composants logiciels, classes..) de haut niveau ne
doivent pas dépendre des modules de bas niveau. Les deux
doivent dépendre d'abstraction.
III- JUnit : Tests unitaires
Tester, c’est exécuter un programme dans le but de constater
des défaillances et de trouver des fautes

Le test du logiciel consiste à vérifier dynamiquement que le

comportement d’un programme est conforme au
comportement attendu.

Cette vérification est faîte sur un ensemble fini de cas de test,

sélectionnés de façon adéquate parmi l’ensemble
potentiellement infini des cas possibles.

JUnit est l'un des Frameworks de tests unitaires les plus

populaires pour les développeurs Java.

- Annotations de JUnit

@Test indique que la méthode est exécutée comme un test.

@BeforeEach indique que la méthode doit être exécutée avant

chaque test dans la classe, de façon à exécuter certaines
conditions préalables nécessaires pour le test.

@BeforeAll indique que la méthode statique à laquelle est

attachée doit être exécutée une fois avant tous les tests de la
classe.

@AfterEach indique que la méthode est exécutée après

l'exécution de chaque test
@AfterAll peut être utilisée lorsqu'une méthode doit être
exécutée après l'exécution de tous les tests dans une classe.

@Ignore peut-être utilisée lorsque vous souhaitez désactiver

temporairement l'exécution d'un test spécifique. Chaque
méthode qui est annotée avec @ignore ne sera pas exécuté.

@NullSource, @EmptySource et @NullAndEmptySource pour

tester la méthode avec une valeur nulle et vide

@EnumSource afin d'exécuter un test avec des valeurs

différentes d'une énumération

@CsvSource accepte un tableau des valeurs séparées par une

virgule et chaque case du tableau correspond à une ligne dans
un fichier CSV.
Par défaut, la virgule sépare les colonnes mais nous pouvons
changer la virgule en utilisant l’attribut « delimiter » :

@MethodSource approche pour fournir des arguments plus

complexes consiste à utiliser une méthode comme source
d'arguments.

@RepeatedTest() pour ordre et répétition

@Test @Disabled désactiver un test

@Test @DisabledOnJre(JRE.JAVA_8) désactiver sur une version

java précise
- Fonctions JUnit :

assertEquals() Vérifier l'égalité de deux valeurs de type primitif

ou objet (en utilisant la méthode equals()).

assertNotEquals() : contraire de assertEquals()

assertFalse() Vérifier que la valeur fournie en paramètre est

fausse

assertTrue() Vérifier que la valeur fournie en paramètre est

vraie

assertNull() Vérifier que l'objet fourni en paramètre soit null

assertNotNull() contraire de assertNull()

assertSame() Vérifier que les deux objets fournis en paramètre

font référence à la même entité
Exemples identiques :
assertSame("Les deux objets sont identiques", obj1, obj2);
assertTrue("Les deux objets sont identiques ", obj1 == obj2);

assertNotSame() contraire de assertSame()

assertArrayEquals(Type[] attendu, Type[]effectif) : égal

“profond” sur les tableaux

assertThrows(Class typeException, Executable exécutable) :

exécutable doit lever une exception du type spécifié

assertDoesNotThrows(Class typeException, Executable

exécutable) contraire de assertThrows()
assertTimeout(Duration durée, Executable exécutable):
L’exécutable s’exécute complètement, mais il faut que sa durée
d’exécution soit inférieure à durée pour que le test soit
considéré comme réussi

assertTimeoutPreemptively(Duration durée, Executable

exécutable) I’exécution est interrompue si elle n’est pas
terminée au bout du délai spécifié

IV- Selenium WebDriver

Selenium est un ensemble d'outils conçus pour automatiser les
navigateurs. Il est couramment utilisé pour les tests
d'applications Web sur plusieurs plates-formes telles que:
• GeckoDriver (Mozilla Firefox)
• ChromeDriver (Google Chrome)
• SafariDriver (Apple Safari)
• InternetExplorerDriver (MS InternetExplorer)
• MicrosoftWebDriver ou EdgeDriver (MS Edge)
• OperaChromiumDriver (navigateur Opera)

Quelques outils sont disponibles sous le parapluie Selenium,

tels que Selenium WebDriver et Selenium IDE.

WebDriver est une interface de contrôle à distance qui vous

permet de manipuler des éléments dans des pages Web et de
contrôler le comportement des agents utilisateurs.

Selenium WebDriver est un Framework de tests automatisés

dédié aux tests d’une application web.
Quoi savoir sur Selenium Webdriver

Importation de packages :
Pour commencer, vous devez importer les deux packages
suivants :

org.openqa.selenium.* : contient la classe WebDriver

nécessaire pour instancier un nouveau navigateur chargé avec
un pilote spécifique.

org.openqa.selenium.chrome.ChromeDriver : contient la classe

ChromeDriver nécessaire pour instancier un pilote spécifique à
Chrome sur le navigateur instancié par la classe WebDrive

Instanciation d'objets et de variables

Normalement, c'est ainsi qu'un objet pilote est instancié.

Lancement d'une session de navigateur

La méthode get() de WebDriver est utilisée pour lancer une
nouvelle session de navigateur et la dirige vers l'URL que vous
spécifiez comme paramètre. driver.get(baseUrl);

Cliquer est peut-être le moyen le plus courant d'interagir avec

des éléments Web. click()

Obtenir le titre réel de la page

La classe WebDriver a la méthode getTitle() qui est toujours
utilisée pour obtenir le titre de la page actuellement chargée.
titrereel = driver.getTitle();
Terminer une session de navigateur
La méthode « close() » est utilisée pour fermer la fenêtre du
navigateur. driver.close(); qui ferme uniquement la fenêtre du
navigateur que WebDriver contrôle actuellement
Alors que driver.quit() pour fermer toutes les fenêtres que
WebDriver a ouvertes.

Localisation des éléments de l'interface graphique:

s'effectue à l'aide de la méthode « findElement(By. locator ()) »
V- SonarQube
SonarQube est un logiciel open source de mesure de la qualité
du code source de projets de développement.
II permet d'obtenir des informations sur la qualité au
niveau du projet, du fichier ou d'un module, donne des
indications sur chaque problème de qualité détecté et le temps
de remédiation en inspection le code en continu.

II supporte plus d'une vingtaine de langages de programmation,

dont C/C++, C#, Java, Python, PHP, JavaScript et est traduit en
une vingtaine de langues.

Il contient un tableau de bord des projets avec son nom, s'il est
prêt à être mis en production (passed) ou non (failed), langages
utilisés, etc…
VI- Mockito

Supposons qu’on a besoin d’implémentation d’une classe A qui

va utiliser une classe B et que la classe B n’est pas encore
implémentée et on possède uniquement son interface (les
prototypes des méthodes qu’elle contient).

Mockito alors permet d’imiter(to mock en anglais) le

comportement de la classe B.

Dans les tests logiciels, on utilise généralement un acteur de

substitution qui joue le rôle de la classe que vous avez besoin
d’utiliser ; c’est ce qu’on appelle
un test double en anglais (doublure de test).

Le principe, c'est d'utiliser du code qui prétend être l’élément

dont vous avez besoin pour vos tests.

Méthodes importantes de Mockito

when(objetDeonnexionImite.verifierLoginEtMotdepasse(any(St
ring.class), any(String.class))).thenReturn(true);

Cette vérification, si verifierLoginEtMotdepasse est appelé, on

retourne Vrai

verify(objetDeonnexionImite,times(2)).verifierLoginEtMotdepas
se(any(String.class), any(String.class));
Cette vérification, si verifierLoginEtMotdepasse est appelé plus
que 2 fois, le test échouera !

verify(objetDeonnexionImite,times(0)).verifierLoginEtMotdepas
se(any(String.class), any(String.class));

ou

verify(objetDeonnexionImite,never()).verifierLoginEtMotdepass
e(any(String.class), any(String.class));

Ces deux vérifications, si verifierLoginEtMotdepasse est appelé,

le test échouera !

Exemple Mockito :
Solution :
@BeforeEach
public void setUp() {
modePaiement = mock(ModePaiement.class);
traitementCommande = new
TraitementCommande(modePaiement);
commande = new Commande();
}

@Test
public void testTraiterCommandeAccepte() {

when(modePaiement.traiterPaiement(commande)).thenRetu
rn(true);
boolean estAccepte =
traitementCommande.traiterCommande(commande);
verify(modePaiement).traiterPaiement(commande);
assertEquals(true, estAccepte);
}
Exemple Selenium :
Solution :

driver.get(baseUrl);
actualTitle = driver.getTitle();
WebElement cote=driver.findElement(By.name("cote_a"));
WebElement cote_b =driver.findElement(By.name("cote_b"));
WebElement cote_c = driver.findElement(By.name("cote_c"));
WebElement boutton_v =
driver.findElement(By.name("valider"));
boutton_v.click();
String contenuRes = res.getText();

@YM-G6