• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Ce cours est en vidéo.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Mis à jour le 30/04/2018

Tips & Tricks pour améliorer la qualité de votre code

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

Votre mini-application SaveMyTrip est maintenant terminée, et vous en êtes vraiment très satisfaits. Tellement que vous l'avez lancée récemment sur le Play Store... et elle cartonne ! :soleil: Vous avez d'ailleurs même dû embaucher plusieurs développeurs afin de la maintenir et de la faire évoluer.

Franchement, je suis trop content ! Bon par contre, travailler en équipe, ce n'est pas facile... surtout qu'il faut que je vérifie constamment que mes collaborateurs ne cassent pas tout le code qui a déjà été créé ! :euh:

Ah ! Eh bien cela peut-être facilement évité, notamment grâce à l'intégration continue ! :)

Je n'ai absolument aucune idée de ce dont tu me parles...

Oui j'en ai bien l'impression... ;) Et bien voici la définition de Wikipédia, qui résume bien ce concept :

L'intégration continue est un ensemble de pratiques utilisées en génie logiciel consistant à vérifier à chaque modification de code source que le résultat des modifications ne produit pas de régression dans l'application développée. 

Le principal but de cette pratique est de détecter les problèmes d'intégration au plus tôt lors du développement. De plus, elle permet d'automatiser l'exécution des suites de tests et de voir l'évolution du développement du logiciel.

En fait, actuellement, vous avez déjà créé quelques tests qui "protègent" d'une certaine façon votre code, et qui vous permettent d'être relativement sereins sur la suite de votre développement. Cependant, quand vous travaillez en équipe, une erreur est vite arrivée : un développeur qui modifie une fonctionnalité et qui n'exécute pas les tests, puis qui publie en production votre application... et là, c'est le drame ! Une régression survient, chose que vous auriez pu éviter si les tests avaient été lancés en amont, de manière automatisée.

Eh bien grâce à l'intégration continue, vous allez pouvoir automatiser ce processus assez facilement... ;) Ainsi, dans ce dernier chapitre, je vais vous montrer comment automatiser le lancement de vos tests grâce à Travis-ci, logiciel libre d'intégration continue, couplé à Codecov, logiciel permettant de générer des rapports de couverture de code.

Installation de Travis

Dans un premier temps, je vous invite à créer votre compte sur le site de Travis grâce à vos identifiants Github.

Tiens, pourquoi est-ce que Travis a besoin de mes identifiants Github ? :o

Pour la simple et bonne raison que Travis est fortement intégré à Github ! En fait, dès que vous allez envoyer un commit sur votre dépôt Github, Travis lancera automatiquement les tests présents à l'intérieur de votre projet afin de vous alerter si le commit en question comporte des problèmes ou non... :)

Une fois l'authentification à Travis passée, la page suivante apparaît :

Synchroniser Travis avec Github
Synchroniser Travis avec Github

Cliquez sur le bouton "Sync account" afin que Travis puisse récupérer la liste de vos dépôts. Une fois cela fait, nous allons activer Travis sur le dépôt contenant le code source de notre application SaveMyTrip :

Activation du dépôt contenant notre application SaveMyTrip
Activation du dépôt contenant notre application SaveMyTrip

Maintenant, récupérez le token de Travis se trouvant en haut à gauche de la page d'administration de Travis, en cliquant sur le bouton "Copy Token" :

Récupération du Token de Travis
Récupération du Token de Travis

Puis, dirigez-vous vers le dépôt Github contenant le code source de votre mini-application SaveMyTrip, et cliquez sur le bouton "Settings" :

Accès aux paramètres d'un dépôt Github
Accès aux paramètres d'un dépôt Github

Cliquez ensuite sur "Integrations & services" puis sur "Travis CI", et ajoutez votre identifiant Github dans le champ "User" et le token précédemment récupéré de Travis dans le champ "Token" :

Intégration de Travis dans un dépôt Github
Intégration de Travis dans un dépôt Github

Puis, enregistrez en cliquant sur le bouton "Update service". Maintenant, nous allons passer à la configuration d'un service nous permettant de générer automatiquement des rapports de couverture de code, afin que nous puissions mesurer avec précision le pourcentage de notre code couvert par nos tests. Ce service s'appelle Codecov.

Connectez-vous-y, et cliquez sur le bouton "Add a repository" :

Ajouter un dépôt à Codecov.
Ajouter un dépôt à Codecov

Sélectionnez le dépôt contenant le code source de votre mini-application SaveMyTrip, et c'est tout... :)Pas besoin de configurer autre chose de ce côté !

Configuration de l'application Android

Maintenant, nous allons devoir configurer notre mini-application SaveMyTrip afin qu'elle puisse générer des rapports de couverture de code à chacun de ses builds. Pour cela, nous allons installer la librairie Jacoco-Android.

Fichier build.gradle au niveau de votre projet : 

buildscript {
    
    repositories {
        google()
        jcenter()
    }
    
    dependencies {
        ...
        
        classpath 'com.dicedmelon.gradle:jacoco-android:0.1.1'
    }
}

Fichier build.gradle au niveau de votre application :

apply plugin: 'jacoco-android'

android {
    ...
    buildTypes {
        ...
        debug {
            testCoverageEnabled true
        }
    }
    ...
}

Et voilà ! Jacoco est installée. Nous avons pensé également à activer la génération de rapports de couverture grâce à la ligne  testCoverageEnabled true . Nous allons pouvoir maintenant passer à la configuration de Travis, en créant à la racine de notre dépôt Github, le fichier de configuration suivant :.travis.yml 

Fichier .travis.yml : 

language: android
jdk: oraclejdk8

env:
  global:
   - ANDROID_API_LEVEL=27
   - EMULATOR_API_LEVEL=22
   - ANDROID_BUILD_TOOLS_VERSION=27.0.3
   - ANDROID_ABI=armeabi-v7a

android:
  components:
    - build-tools-$ANDROID_BUILD_TOOLS_VERSION
    - android-$EMULATOR_API_LEVEL
    - sys-img-armeabi-v7a-android-$EMULATOR_API_LEVEL

before_install:
  - yes | sdkmanager "platforms;android-27"

before_script:
  - chmod +x gradlew
  - ./gradlew build jacocoTestReport assembleAndroidTest
  - echo no | android create avd --force -n test -t android-$EMULATOR_API_LEVEL --abi $ANDROID_ABI
  - emulator -avd test -no-skin -no-audio -no-window &
  - android-wait-for-emulator
  - ./gradlew connectedCheck

after_success:
  - bash <(curl -s https://codecov.io/bash)

Explications : Ce fichier sera lu par le service Travis directement depuis votre dépôt Github. C'est d'ailleurs pour cette raison que vous devez absolument le placer à la racine de celui-ci.

Vous retrouverez plus d'informations sur l'ensemble des paramètres de ce fichier sur le site de Travis. Pour résumer, Travis lancera automatiquement, grâce à la commande  ./gradlew build jacocoTestReport assembleAndroidTest, les tests de notre projet sur un émulateur virtuel. Une fois ces derniers terminés, un rapport de couverture de code sera envoyé sur le site Codecov.io grâce au paramètre  after_success  et la commande  bash  en dessous.

Une fois ce fichier rempli, effectuez un commit de votre projet Android sur Github, afin que Travis puisse s'exécuter. Vous devriez voir, depuis l'interface web de Github, l'image correspondante à votre commit : 

Le service Travis s'exécute sur votre commit...
Le service Travis s'exécute sur votre commit...

Le petit rond orange indique que Travis est en train d'analyser votre code et exécuter l'ensemble de vos tests. Cela peut prendre un peu de temps, généralement un petit quart d'heure, car Travis doit lancer un émulateur virtuel afin de lancer vos tests instrumentalisés... ;)

Dès que Travis aura terminé d'exécuter vos tests, le rond passera à la couleur verte ou rouge, en fonction de leur réussite ou de leur échec.

Résultats des tests
Résultats des tests

D'ailleurs, si vous cliquez sur le service codecov, vous pourrez visualiser l'intégralité du rapport de couverture de code... :)

Rapport de couverture de code
Rapport de couverture de code

A titre d'exemple, vous pouvez retrouver le mien publiquement à ce lien ainsi que l'exécution de mes tests sur Travis. Bon, comme vous pouvez le voir, nous avons un taux de couverture de notre code par nos tests d'environ 15 %... C'est bien... mais peut mieux faire ! >_<

D'ailleurs, le but n'est pas forcément d'atteindre les 100 %, mais plutôt de couvrir par des tests l'ensemble des fonctionnalités métiers de notre code.

Conclusion

Et voilà, ce cours se termine ! J'espère que vous l'aurez apprécié et surtout bien compris... :) Vous venez, sans forcément vous en rendre compte, de faire un pas de géant dans le développement sur Android ! Nous avons vu énormément de concepts assez avancés, donc prenez bien le temps de les assimiler.

Nous avons vu comment stocker des données dans les différents espaces de stockage sur Android à l'intérieur d'un fichier texte ainsi que l'exposer publiquement de manière sécurisée. Nous avons également étudié le moyen de stocker des données structurées en utilisant une base de données SQLite, grâce à la libraire Room. Et enfin, nous nous sommes penchés sur la manière d'améliorer la qualité de nos applications Android grâce à l'Architecture Components ainsi qu'à l'intégration continue.

Et comme toujours, pensez à pratiquer, pratiquer et encore pratiquer, afin que coder devienne aussi naturel que respirer... :p

A très bientôt dans un prochain cours !

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