---
# System prepended metadata

title: Formation Appium Zenity
tags: [webdriver, UI tests, Appium, Zenity, java, Test automation]

---

---
title: Formation appium
tags: Appium, java, webdriver, Zenity
description: Notes de lecture sur la formation Appium de Zenity. 
---


## Présentation de [appium](https://appium.io/docs/en/2.2/) 

Appium est un outil open source conçu pour faciliter l’automatisation des interactions sur les interfaces utilisateur des applications et sur la plupart des supports disponibles : smartphone (Android, iOS), smart TV, les navigateurs (Firefox, chrome, Safari) et les applications pour pc (Windows et macOS). Appium est majoritairement utilisé pour l’automation des tests UI, et nous nous intéresserons ici au cas particulier de l’automatisation des tests d’interfaces utilisateurs sur les smartphones Android et iOS. En fonction du système d’exploitation mobile, du langage de programmation utilisé, on va distinguer trois grands types d’application mobile.

### Les Types d’application mobile 

#### Les applications natives

Ce sont des applications conçues pour fonctionner sur un système d’exploitation et une plateforme précise. C’est le cas par exemple des applications développées en Swift pour iOS et les applications développées en java pour Android.

#### Les applications mobile web

Ce sont des applications pour mobile accessible par le biais d’un navigateur ; ils ne sont, de ce fait, pas limité par les contraintes liées au système d’exploitation. Ce sont bien souvent des applications développées à l’aide des technologies web (HTML, CSS, JavaScript…)

#### Les applications hybrides

Comme le nom l’indique, ce sont des applications qui sont développées à l’aide d’une combinaison des techniques et outils de développement natifs et web. Il s’agit généralement d’applications natives qui font recours à la technologie [webview](https://developer.android.com/reference/android/webkit/WebView) pour présenter certaines interfaces ou informations à l’utilisateur.

#### Les applications cross-plateforme

Ce sont des applications développées dans l’intention d’obtenir un exécutable pour des plateformes existantes à l’aide d’un seul code source. Ceci est possible à l’aide des technologies comme **flutter**, **react native**, **xamarin** et plusieurs autres.

Pour chacun de ces types d’application, ils existent des techniques et des outils libres ou propriétaires pour l’automatisation de tests d’interface utilisateur, on a par exemple  Uiautomator, **Uiautomator2** et **Expresso** pour Android, **XCUITest** pour l’automatisation des tests sur iOS. 


#### Architecture de Appium

L’architecture de Appium est  constitué d’un client et d’un serveur, suivant l’architecture **REST**,  qui communiquent à l’aide du protocole **HTTP**. Cette architecture permet à Appium d’être indépendant à un langage de programmation particulier, mais surtout de pouvoir developper des scripts d’automatisation cross plateforme

##### Appium server

Appium serveur est une application NodeJS configuré, en fonction des besoins, pour pouvoir  recevoir des requêtes **HTTP** sur un port donné, interprété les instructions et exécuté les requêtes des drivers, sur un terminal donné dans les configurations.

###### [Driver](https://appium.io/docs/en/2.2/intro/drivers/)

L’utilisation des drivers est la solution choisie par Appium pour pouvoir adresser plusieurs plateformes avec des technologies différentes. 

Un driver Appium est une interface qui étend le protocole Webdriver et permet à Appium d’interagir avec les différentes plateformes. Nous avons, par exemple, Appium **Expresso** driver et Appium **UIAutomator2** driver  pour Android et Appium **XCUITest** driver pour iOS.

##### [Plugins](https://appium.io/docs/en/2.2/ecosystem/#plugins:~:text=in%20other%20clients.-,Plugins,-Appium%20Plugins%20offer)

Les plugins étendent les capacités de Appium et lui permettent de réaliser plus facilement certaine tâche comme la comparaison d’image.


##### Client Appium 

Comme présenté plus haut, Appium repose sur une architecture **REST** dans laquelle client fait appel à un serveur et présente le résultat à l’utilisateur. Il excite deux types de client appium, des clients permettant de communiquer avec le serveur à l’aide d’un langage de programmation particulier, et les clients avec des interfaces utilisateurs graphiques. Le client appium en interface utilisateur le plus connu est Appium inspector, qui est un logiciel desktop disponible pour tous les systèmes d’exploitations et qui permet de t’automatiser les interactions  sur les mobiles à l’aide de Appium en utilisant une interface graphique.


## Installation de appium 

### Installation du Serveur Appium


* Un système d’exploitation :  Windows, Linux ou macOS
* Une invite de commande : 
    * installer [Git Bach]("https://git-scm.com/downloads") sur Windows, 
    * Utiliser un terminal natif sur les systèmes basés sur Linux (Ubuntu, macOS)

Appium est une application NodeJS développé en JavaScript; JavaScript étant un langage destiné aux navigateurs, nous avons besoin d’un environnement d’exécution  qui servira de surcouche pour exécuter du JavaScript sur le système d’exploitation ;  pour ce faire, nous avons besoin de : 

* [Nodejs]("https://nodejs.org/en"): Un environnement d’exécution JavaScript pour tous les systèmes d’exploitation.
* [Npm]("https://www.npmjs.com/"): Un système de gestion de paquet pour NodeJS en JavaScript.

#### Installation de NodeJS

##### Sur windows
Pour installer Nodejs sur windows, il faut: 

1. [Télécharger]("https://nodejs.org/en/download/") l’exécutable de l’application avec l’extension “.msi” . De préférence une version LTS (Long Term support)  qui est stable sur une longue période

![télécharger l'exécutable de nodejs](https://hackmd.io/_uploads/B1nsq7JI6.png)

3. Exécuté le fichier d’installation et suivre les étapes comme dans les captures d'écran

![image115](https://hackmd.io/_uploads/H1fDz4JIa.png)

![image116](https://hackmd.io/_uploads/SyGvGVyIp.png)

![image117](https://hackmd.io/_uploads/ByfvGVk86.png)

![image108](https://hackmd.io/_uploads/rkF9fVk8T.png)

![image92](https://hackmd.io/_uploads/Hk5VQNyLp.png)

5. Ajouter la variable d’environnement NODE_HOME


##### Sur macOS

Pour installer nodejs sur macOS, il existe plusieurs possibilités, en utilisant directement l’exécutable ou en utilisant un gestionnaire dépendance en invite de commande.

###### Avec L’exécutable 

Pour installer nodejs sur macOS, il existe plusieurs solutions, en utilisant directement l’exécutable ou en utilisant un gestionnaire dépendance en invite de commande.

1. [Télécharger]("https://nodejs.org/en/download/") le fichier dédié à macOS identifiable par l’extension **.pkg**

![Télécharger nodejs pour mac](https://hackmd.io/_uploads/S1u86EkLT.png)

2. Exécuter le programme d'installation et suivre les étapes comme sur les captures d'écran:

![Installer nodejs sur mac 01](https://hackmd.io/_uploads/ByoY_LyLT.png)

![Installer nodejs sur mac 02](https://hackmd.io/_uploads/ryTzq8yLa.png)

![Installer nodejs sur mac 03](https://hackmd.io/_uploads/rJpzqIJ86.png)

![Installer nodejs sur mac 04](https://hackmd.io/_uploads/Skpf9IkUp.png)

![Installer nodejs sur mac 05](https://hackmd.io/_uploads/Hk6M581Ip.png)

![Installer nodejs sur mac 06](https://hackmd.io/_uploads/SyvxjUyU6.png)

###### Avec un gestionnaire de packet

Ils existent plusieurs outils de gestion de dépendances en fonction des systèmes d’exploitation. L'outil recommandé pour l’installation de nodeJs  est [**nvm**](https://github.com/nvm-sh/nvm/blob/master/README.md) pour nodejs version manager. 

Exécuter la commande suivante pour installer nvm: 

```bash!
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Ou encore 

```bash!
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```

Installer la dernière version node à l'aide de la commande:

```bash!
nvm install node 
```
Cette commande installe la dernière version de node et la version de npm associé on peut facilement verifier l'installation  de Node à l'aide de la commande:

```bash!
node --version
```
Et vérifier l'installation de npm avec la commande: 

```bash!
npm --version
```

#### Installation de Appium Server

Une fois que nous avons installé l’environnement d’exécution node, et le gestionnaire de paquet npm, nous pouvons installer **appium** à l’aide de la commande suivante:

```bash!
npm i --location=global appium
```

Nous pouvons également vérifier l'installation de Appium à l'aide de la commande:

```bash!
appium --version
```

##### Appium-doctor
Les précédentes manipulations nous ont permis d’installer appium, mais pour qu’il fonctionne correctement, il reste quelques outils à installer et des  variables d’environnement à intégrer à notre système. Pour savoir lequel, nous disposons d’un outil très pratique [**Appium-doctor**](https://github.com/appium/appium-doctor). Il s’agit d’une application nodejs en ligne de commande qui scanne le système pour vérifier l’état des dépendances de appium. Pour l’installer, il suffit d’exécuter la commande:

```bash!
npm install appium-doctor -g
```

Vérifions l'installation avec la commande: 

```bash
appium-doctor --version
```
Nous allons ensuite exécuter la commande: 

```bash
appium-doctor
```
Le résultat ressemble à ceci 

![output-appium-doctor](https://hackmd.io/_uploads/Hk4eNL4Up.png)

Le résultat de l’exécution de la commande sous forme de logs nous informe sur l’état des dépendances. En fonction des systèmes et des logiciels préalablement installer sur votre système, vous aurez un ensemble d’informations et d’alertes. Mais de façon générale, ce logiciel, va vérifier l’installation de :

* NodeJS qui est globalement utilisé par appium server
* Java, en vérifiant la variable d’environnement PATH. Java est utilisé pour les applications Android et utilisé par certaines drivers de appium server.
* Xcode, qui est l’éditeur de code pour les applications iOS
* Xcode command line tools qui permet d’interagir avec les emulateurs IOS
* adb, android et emulator qui sont des outils permettant d’émuler des devices android 
* La variable d’environnement ANDROID_HOME, qui permet d’accéder aux outils adb, android et emulator.
* Et d’autres dépendances qui sont marquées comme optionnelles.

#### Installation de dépendances 

##### Installer java et ajouter JAVA_HOME  au PATH

**Java** est un langage de programmation orienté objet, multiplateforme. Pour installer java, nous disposons de la **JDK** (java Development kit) qui est un ensemble d’outils permettant d’interpréter, compiler et exécuter des applications JAVA.
Pour télécharger la JDK, aller sur ce [site](https://www.oracle.com/fr/java/technologies/downloads/) et télécharger la version adapter à votre système d’exploitation. 

![downlaod-java-version](https://hackmd.io/_uploads/S1spbYEU6.png)

Exécuter le programme et suivre pour insaller la vertion de la jdk (java development kit) adapté. 

Pour la suite de la formation, nous avons besoin que java soit accessible par la ligne de commande, pour ce faire, il suffit d’ajouter le chemin de l’exécutable de java à la variable d’environnement path, sur windows, en suivant ces [instructions](https://www.java.com/fr/download/help/path_fr.html) pour ajouter java  à la variable d'environnement path. Pour les systems basés sur UNIX, editer le fichier *bashrc* et ajouter la ligne suivante:

```bash
export PATH=/usr/java/<JDK Directory>/bin:$PATH
```

Actualiser le contexte à l'aide de la commande:

```bash
cd $HOME && source .bashrc
```

##### Installer Android Studio et ajouter la variable d’environnement ANDROID_HOME au PATH

Android Studio est un environnement de développement pour développer des applications mobiles Android.  Il permet d’installer tous les outils nécessaires pour le développement d’application Android. Pour le télécharger, il suffit de se rendre sur ce [site](https://developer.android.com/studio).

![download-android-studio](https://hackmd.io/_uploads/S1oeRoN86.png)

Cliquer sur le bouton pour télécharger la version qui correspond au système d'exploitation souhaité.

Installer android studio en exécutant le programme d’installation et en exécutant le programme d'installation.

Le **SDK** Android (Software Development Kit) est un ensemble d'outils et de bibliothèques nécessaires pour développer des applications pour la plateforme Android.

Installer la SDK et les outils android (adb, android et emulator) necessaire pour appium en suivant les étapes suivantes: 

![Capture d’écran 2023-12-13 à 16.33.13](https://hackmd.io/_uploads/SJRVQIDI6.png)

![Capture d’écran 2023-12-13 à 16.33.21](https://hackmd.io/_uploads/Hk1rQLw8T.png)

![Capture d’écran 2023-12-13 à 16.34.14](https://hackmd.io/_uploads/By1Sm8w8p.png)

![Capture d’écran 2023-12-13 à 16.34.31](https://hackmd.io/_uploads/SJkSmUw8p.png)

![Capture d’écran 2023-12-13 à 16.36.36](https://hackmd.io/_uploads/SkyrX8DIa.png)

![Capture d’écran 2023-12-13 à 16.38.49](https://hackmd.io/_uploads/SykrXIP8p.png)


**ANDROID_HOME** est une variable d'environnement utilisée dans le développement d'applications Android. Elle pointe vers le répertoire d'installation du **SDK** Android sur un système. 

Lorsque vous développez des applications Android à l'aide d'outils comme Android Studio, il est souvent nécessaire de définir la variable **ANDROID_HOME** pour indiquer à ces outils où se trouve le SDK Android sur votre système. Cela permet aux outils de trouver les bibliothèques, les outils de build et autres composants nécessaires au développement d'applications Android.

Définir correctement la variable **ANDROID_HOME** est important pour garantir que les outils de développement puissent accéder au SDK Android sans problèmes.

#### Pour ajouter la variable ANDROID_HOME sur window

1. **Trouver l'emplacement du SDK Android:**
Notez le chemin d'installation du SDK Android sur votre ordinateur. Par défaut, il est souvent installé dans le répertoire **`C:\Users\YourUsername\AppData\Local\Android\sdk`** mais cela peut varier selon votre installation.
3. **Ajouter ANDROID_HOME comme variable d'environnement:** 
* Cliquez avec le bouton droit sur l'icône Windows dans la barre des tâches, puis sélectionnez "Système".
* Dans la fenêtre qui s'ouvre, cliquez sur "Informations système".
* Sur le côté gauche, cliquez sur "Paramètres système avancés". Cela ouvrira une nouvelle fenêtre.
* Dans la nouvelle fenêtre, cliquez sur "Variables d'environnement".
* Dans la section "Variables système", cliquez sur "Nouvelle..." pour ajouter une nouvelle variable.
* Dans le champ "Nom de la variable", entrez ANDROID_HOME.
* Dans le champ "Valeur de la variable", collez le chemin d'installation du SDK Android que vous avez noté précédemment.
* Cliquez sur "OK" pour valider et fermer toutes les fenêtres.
5. **Modifier la variable PATH (optionnel mais recommandé)**:
Pour faciliter l'utilisation du SDK Android à partir de n'importe quel répertoire dans l'invite de commandes, vous pouvez ajouter le chemin vers les outils du SDK à la variable PATH.

* Sélectionnez la variable Path dans la section "Variables système".
* Cliquez sur "Modifier...".
* Ajoutez le chemin **`;%ANDROID_HOME%\tools;%ANDROID_HOME%\platform-tools`** à la liste des chemins. Assurez-vous de séparer chaque chemin par un point-virgule.
7. **Redémarrez votre ordinateur**:
Pour que les modifications prennent effet, il est recommandé de redémarrer votre ordinateur après avoir ajouté ces variables.

#### Pour ajouter la variable ANDROID_HOME linux et Mac

1. **Trouver l'emplacement du SDK Android:**

Notez le chemin d'installation du SDK Android sur votre ordinateur. Habituellement, il est installé dans un répertoire comme **`/home/votre_nom_d_utilisateur/Android/Sdk.`**

2. **Modifier le fichier de profil:**

Ouvrez le fichier .bashrc ou .bash_profile (selon votre distribution Linux) avec un éditeur de texte comme nano ou vim. Vous pouvez le faire en exécutant la commande suivante dans le terminal:

```bash
nano bashrc
```

Ajoutez la ligne suivante à la fin du fichier en remplaçant **`/chemin/vers/votre/SDK`** par le chemin d'accès réel de votre SDK Android :

```bash
export ANDROID_HOME=/chemin/vers/votre/SDK

```
Enregistrez les modifications.

3. **Rafraîchir la configuration du profil:**

Pour appliquer les changements que vous avez apportés au fichier de profil, exécutez la commande suivante dans le terminal:

```bash
source ~/.bashrc
```
Notre processus d'installation des logiciels requis pour le bon fonctionnement du serveur Appium est désormais terminé. Toutefois, comme nous l'avons évoqué précédemment, Appium nécessite des drivers spécifiques pour interagir efficacement avec les applications mobiles. En particulier, pour l'écosystème Android, nous dépendons des driver Uiautomator et Espresso. Quant à l'environnement iOS, le driver XCUITest est crucial pour assurer une interaction harmonieuse avec les applications sur ces appareils. Ces pilotes représentent une composante essentielle pour garantir la cohérence et la précision des interactions entre Appium et les applications, et c'est pour cette raison que nous nous concentrons sur ces pilotes spécifiques pour l'instant. Nous pouvons installer les drivers à l'aide des commandes suivantes: 

```bash
appium driver install uiautomator2
```

``` bash
appium driver install xcuitest
```

```bash
appium driver install espresso
```

Nous avons installé avec succès le serveur Appium, prêt à être déployé pour nos besoins. Pour lancer ce serveur et le rendre opérationnel, il vous suffit d'exécuter une commande spécifique à partir de votre interface de commande. En entrant cette commande dans votre terminal ou votre invite de commande, vous activez le serveur Appium, permettant ainsi une interaction fluide avec vos applications mobiles pour des tests automatisés efficaces et des validations précises.

```bash
appium
```

Le reultat devrai ressembler à ceci: 

```bash
[Appium] Welcome to Appium v2.0.0
```

Maintenant que nous avons mis en place avec succès Appium Server, il est temps de configurer un client Appium pour interagir avec ce serveur. 
