• 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 06/01/2021

Découvrez les tests

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Bienvenue dans cette partie sur les tests unitaires ! Oui cette partie nécessite que je vous souhaite à nouveau la bienvenue, car sans vouloir en faire des tonnes, nous allons nous attaquer au sujet le plus important de votre vie !

Heureusement que tu as dit que tu n'en ferais pas des tonnes...

Bon, le sujet le plus important de votre vie de programmeur en tout cas.

Et ce sujet, c'est évidemment les tests.

Meme d'un écureuil les bras au ciel qui hurle : Oui, les tests !
Bon Tac, ton frère vient de faire la blague...

Qu'est-ce que les tests ?

Nous voilà déjà face à la grande question : qu'est-ce que sont les tests ?

C'est très simple et vous en faites déjà ! Lorsque vous développez une application, votre premier réflexe est de lancer l'app dans le simulateur pour voir si ça marche. Vous cliquez sur les boutons ou faites les actions que vous souhaitez contrôler et vous constatez que cela fonctionne comme prévu ou non.

Et bien c'est exactement un test ! Vous testez que votre programme se comporte comme prévu.

Plus précisément, vous faites ce que l'on appelle un test manuel. Les tests manuels sont utiles, mais ont deux défauts principaux :

  • Ils sont lents, il faut compiler le code, lancer le simulateur, charger l'application, parfois faire plusieurs actions avant de pouvoir tester ce qu'on souhaite tester.

  • Ils ne sont pas fiables. Avec un test manuel, vous allez vérifier qu'une action fonctionne, mais ce n'est pas suffisant. Il faudrait aussi vérifier que vous n'avez pas cassé les autres fonctionnalités de l'application. Et donc finalement, pour que les tests manuels soient fiables, il faudrait qu'à chaque fois que vous changez le code, vous retestiez tout le programme. Vous n'êtes pas prêts de créer le prochain Facebook à cette vitesse :) !

Alors, laissez-moi vous parler des autres formes de tests !

La pyramide des tests

On peut facilement se représenter la typologie des tests avec une pyramide. En haut de la pyramide, on a les tests les plus rarement utilisés qui sont effectués par des humains et en bas, ceux plus couramment utilisés effectués par des ordinateurs.

Schéma de la pyramide de tests

Comme vous pouvez le constater, la pyramide contient trois types de tests différents :

  • Tout en haut, il y a les tests manuels conduits par des humains. Ils sont assez rares, car assez longs comme nous venons de le dire.

  • Tout en bas il y a les tests unitaires. Ce sont des tests automatisés rédigés par des humains, mais effectués par l'ordinateur. Ils sont bien plus nombreux, mais aussi bien plus fréquemment sollicités. On va en parler juste après.

  • Enfin, nous avons entre les deux les tests fonctionnels. Selon les technologies et les méthodologies, ils sont réalisés par des humains ou par l'ordinateur. Dans notre cas en iOS, ce sera plutôt l'ordinateur et on les appelle UI Test. J'y reviens dans une minute.

Voilà la vision globale des tests. Rentrons un peu dans le détail maintenant.

Les tests unitaires

Les tests unitaires permettent de tester des toutes petites unités de votre programme. C'est pour cela qu'ils sont si nombreux. Un test unitaire va tester une seule méthode d'une seule classe au maximum. Si la méthode est grosse, il faudra même peut-être plusieurs tests pour la couvrir.

Prenons un exemple, avec la classe suivante :

class Personne {
var age = 0
func feterSonAnniversaire() {
age += 1
}
}

Je souhaite tester la méthode feterSonAnniversaire avec un test unitaire. Un test unitaire, c'est un petit morceau de code qui ferait la chose suivante :

  1. Créer une instance de la classe Personne avec la propriété age qui vaut 12.

  2. Appeler la méthode feterSonAnniversaire sur cette instance.

  3. Vérifier que la propriété age vaut bien maintenant 13.

Un test unitaire, c'est donc un morceau de code qui va tester une toute petite unité du programme. Donc en général un test unitaire, c'est très simple !

Dit autrement, on a une donnée en entrée qui rentre dans le test unitaire. Si la donnée en sortie correspond à ce que l'on a prévu, le test est réussi.

Schéma d'un test unitaire

Les tests fonctionnels

Nous avons parlé des tests unitaires et des tests manuels. Parlons maintenant des tests fonctionnels qui se situent entre les deux !

Les tests fonctionnels permettent de tester une fonctionnalité complète de l'application, comme la phase de login par exemple.

En iOS, on les appelle UI tests, car ils ont lieu sur l'interface utilisateur. Le principe, c'est que nous allons indiquer au simulateur un certain nombre d'actions à réaliser (appuie sur ce bouton, reviens à la page précédente, glisse vers le bas, etc.) et ensuite, nous allons lui demander de vérifier que ce qui se trouve à l'écran correspond à ce qu'on a prévu. Ce sont donc des tests automatisés : l'ordinateur suit le scénario qu'on lui a donné sur l'interface de l'application.

Quels tests choisir ?

Avec notre pyramide de test, nous voilà bien embêtés ! Quels sont les tests que nous devons choisir d'implémenter dans notre projet ?

La réponse est plus compliquée qu'il n'y paraît. Alors je vais la faire en 2 temps :

1. Utilisez les tests manuels, mais ne vous y fiez pas !

Vous ne pouvez pas vous passer des tests manuels, car c'est un bon moyen de voir si votre application fonctionne dans son ensemble et surtout parce que vous pouvez toujours vous appuyer sur ce que vous voyez ! Donc il faut continuer à les faire, mais ne comptez pas exclusivement sur eux, ils sont lents et pas fiables !

2. Fiez-vous aux tests unitaires

Les tests fonctionnels et les tests unitaires ont l'avantage d'être automatisés. Donc ils vont nous permettre de tester l'intégralité de notre code.

OK, mais on doit utiliser les deux ? Ou que les tests unitaires ? Ou que les tests fonctionnels ?

Je pense que chaque développeur a une réponse différente à cette question. Alors voici la mienne !

Si votre programme est bien architecturé et que vous êtes rigoureux, les tests unitaires doivent vous suffire.

Pourquoi ?

Si votre programme est bien architecturé, toute la logique de votre application est bien rangée dans des classes qui ont chacune un rôle clair et sont donc testables facilement.

De plus, les tests unitaires ont deux avantages sur les tests fonctionnels :

  • Ils sont plus rapides à exécuter. Les tests fonctionnels nécessitent le lancement de l'app dans un simulateur suivi d'un scénario d'actions. Les tests unitaires se résument à évaluer un booléen.

  • Les tests unitaires sont plus faciles à rédiger et à maintenir, car ils concernent chacun une toute petite unité du programme.

En résumé

  • Il existe plusieurs types de tests, des plus couramment appelés aux plus rares :

    • Les tests unitaires

    • Les tests fonctionnels

    • Les tests manuels

  • Un test unitaire, c'est donc un morceau de code qui va tester une toute petite unité du programme.

  • Les tests fonctionnels permettent de tester une fonctionnalité complète de l'application.

  • Je vous suggère de continuer à faire des tests manuels, mais vu qu'ils ne sont pas fiables, complétez-les avec une suite de tests unitaires qui sont rapides, fiables, rapides à rédiger et à maintenir.

Exemple de certificat de réussite
Exemple de certificat de réussite