Les tests Démo 10 : IFT3912

Plan Les tests en général Extreme programming (XP) JUnit Exemples

Les tests Les logiciels deviennent de plus en plus complexes et importants. Pas de programme sans bug! Important de tester avant de distribuer son code.

Les tests On peut distinguer les tests en fonction de leur : objectif : scénario : vérifier que le comportement fonctionnel est bien celui attendu non-regression : ce qui fonctionnait dans les version précédentes du code fonctionne toujours dans la nouvelle version performance (bench) ou charge (load) : les temps de réponse à une requête sont conformes aux attentes intégration/fonctionnels : le code s'intègre bien avec les autres éléments du système. cible : scénarios : tester un cas d'utilisation unitaires : tester un composant du système technologie : Web : envoyer des requêtes Web simulant le comportement d'utilisateur(s)

Les tests Exemples d’outils de tests Test Web Load Runner HttpUnit Tests unitaires JUnit Tests fonctionnels/d'intégration JFunc Test de charge/performance JMeter XP compte parmi ses recommandations les tests unitaires systématiques et les tests d'intégration continue.

Extreme programming (XP) XP est une méthode agile de gestion de projet informatique adaptée aux équipes réduites avec des besoins changeants. Elle pousse à l'extrême des principes simples. Une méthode agile est une méthode de développement informatique permettant de concevoir des logiciels en impliquant au maximum le demandeur (client), ce qui permet une grande réactivité à ses demandes. Une méthode agile est une méthode de développement informatique permettant de concevoir des logiciels en impliquant au maximum le demandeur (client), ce qui permet une grande réactivité à ses demandes. Les méthodes agiles se veulent plus pragmatiques que les méthodes traditionnelles. Elles visent la satisfaction réelle du besoin du client, et non d'un contrat établi préalablement.

Extreme programming (XP) XP repose sur des cycles rapides de développement (des itérations de quelques semaines) dont les étapes sont les suivantes : une phase d'exploration détermine les scénarios clients qui seront fournis pendant cette itération ; l'équipe transforme les scénarios en tâches à réaliser et en tests fonctionnels ; chaque développeur s'attribue des tâches et les réalise avec un binôme ; lorsque tous les tests fonctionnels passent, le produit est livré. Le cycle se répète tant que le client peut fournir des scénarios à livrer. La première livraison est généralement plus importante et n'est réalisée qu'après quelques itérations. Après la première mise en production, les itérations peuvent devenir plus courtes (une semaine par exemple).

Extreme programming (XP) Une bonne pratique de conception est de créer le test d'une fonctionnalité avant d'implémenter cette fonctionnalité (test-driven ou test-first design), afin de : s'assurer de l'adéquation de la conception/réalisation au besoin exprimé par le test garantir qu'une fonctionnalité peut être constamment vérifiée/évaluée au fil de son implémentation.

JUnit Le test unitaire est un procédé permettant de s'assurer du fonctionnement correct d'une partie déterminée d'un logiciel ou d'une portion d'un programme. JUnit désigne un framework de rédaction et d'exécutions de tests unitaires. Imaginé et développé en Java par Kent Beck et Erich Gamma, auteurs des ouvrages "SmallTalk Best Pratice Patterns" et "Design Patterns : Catalogue de modèles de conception réutilisables".

JUnit But: Idée principale: Offrir au développeur un environnement de développement simple, le plus familier possible, et ne nécessitant qu'un travail minimal pour rédiger de nouveaux tests. Idée principale: Représenter chaque test par un objet Un test correspond souvent à une classe du prgm Un test pourra être composé de plusieurs tests unitaires dont le rôle sera de valider les différentes méthodes de vos classes

JUnit Architecture Pattern Composite!! Les programmeurs ont recours à de nombreuses méthodes pour déboguer leurs applications, notamment les sorties console, l'évaluation d'expressions dans les débogueurs ou encore les assertions. Toutes ces approches ont un problème majeur. Dans les deux premiers cas, les développeurs doivent interpréter les résultats pour en tirer des conclusions tandis que dans le dernier, le programme est interrompu par une erreur. JUnit apporte une solution efficace à ces problèmes. Il nous suffit d'écrire une classe dérivant de junit.framework.TestCase et d'y ajouter nos tests.

JUnit

JUnit Méthodes d'assertion Une assertion est un élément de spécification placé au sein du code. Une assertion est caractérisée par une condition booléenne qui doit être vraie. Dans le cas d'un test, une assertion fausse entraîne l'échec du test. En général, on associe à chaque assertion un message d'erreur. Si l'assertion est fausse, le message d'erreur est affiché.

Documentation en ligne sur les assert : JUnit Méthode Rôle assertEquals Vérifie que deux objets sont égaux assertFalse Vérifie que l'expression est fausse assertNotNull Vérifie que l'objet n'est pas nul assertNotSame Vérifie que deux références ne sont pas les mêmes assertNull Vérifie qu'un objet est nul assertSame Vérifie que deux références sont les mêmes assertTrue Vérifie que l'expression est vrai fail Provoque l'échec du test Documentation en ligne sur les assert : http://junit.sourceforge.net/javadoc/junit/framework/Assert.html

import junit. framework. ; import org. javarome. exemple import junit.framework.*; import org.javarome.exemple.MaClasse; public class MonTest extends TestCase {   public MonTest (String someTestName) {      super (someTestName);   }   protected void setUp() {      // Initialisation des tests   }   public void testScenario1() {      // Code du test de scénario 1      final String expected = "EXPECTED RESULT";      String tested = new MaClasse().method ();      assertTrue (expected.equals (tested));   }   public void testScenario2() {      // Code du test de scénario 2   }   protected void tearDown() {      // Nettoyage fin de test   } }

import junit.framework.Test; import junit.framework.TestSuite; public class MyTestSuite { public static Test suite() { TestSuite suite = new TestSuite(); suite.addTestSuite(ATestClass.class); suite.addTest(AnotherTestSuite.suite()); return suite; } /** * Runs the test suite using the textual runner. */ public static void main(String[] args) { junit.textui.TestRunner.run(suite());

Exemples Tiré: http://www.iut-orsay.fr/dptinfo/Pedagogie/Roger.Astier/app_java/javaTest.html

Few reasons to use JUnit JUnit tests allow you to write code faster while increasing quality. JUnit is elegantly simple. JUnit tests check their own results and provide immediate feedback. JUnit tests can be composed into a hierarchy of test suites. Writing JUnit tests is inexpensive. JUnit tests increase the stability of software. JUnit tests are developer tests. JUnit tests are written in Java. JUnit is free! http://clarkware.com/articles/JUnitPrimer.html

Références JUnit Pocket Guide, Kent Beck, 2005 http://gfx.developpez.com/tutoriel/java/junit/ http://www.iut-orsay.fr/dptinfo/Pedagogie/Roger.Astier/app_java/javaTest.html