SAP : un outil fonctionnel

Qu'est-ce que SAP ?

SAP (Systems, Applications and Products) est l'un des principaux producteurs mondiaux de logiciels pour la gestion des processus d'entreprise, en développant des solutions qui facilitent le traitement efficace des données et le flux d'informations dans les organisations.

SAP est utilisé comme gestionnaire de données. C'est un outil indépendant d'Agilitest qui permet de créer des programmes à travers des modules.

Vous pouvez consulter la documentation SAP directement sur le site web de SAP.

L'intégration de SAP avec Agilitest vous permet de créer et maintenir des tests complexes avec une approche fonctionnelle. Les tests SAP GUI peuvent être utilisés pour gérer la modification ou le développement de règles de gestion, ou la mise à jour des fonctionnalités du système ERP.

‍

Comment se connecter à un serveur SAP ?

▶️ Vous pouvez retrouver un tutoriel sur comment se connecter à un serveur SAP sur notre chaîne Youtube.

‍

Pour utiliser SAP, vous devez installer un client : le SAP Logon. Ce client vous permettra d'interagir avec le serveur SAP. Une connexion est établie dans ce client avec les éléments transmis par l'administrateur SAP, notamment le serveur cible.

Pour se connecter à un serveur SAP, l'opération est la même que pour toute autre application testée sur Agilitest.

Commencez donc par un "Démarrer un canal".

Sélectionnez ensuite le raccourci SAP pour définir le site canal dans le menu déroulant de la barre de saisie.

Saisissez les coordonnées du serveur SAP, présentes dans le logon SAP, c'est-à-dire le nom de la connexion, le numéro de client (c'est-à-dire le numéro de mandat associé) et éventuellement la langue (EN/FR/...).

Cliquez ensuite sur "Activer l'autorisation de base" pour entrer vos données de connexion : nom d'utilisateur + mot de passe.

‍

💡 Conseil

Pour éviter que votre mot de passe n'apparaisse dans le test, pensez à créer un mot de passe crypté à partir du menu des propriétés du projet.

‍

Pour démarrer la connexion en anglais, vous pouvez changer la langue dans la partie de connexion en ajoutant"/EN" à la fin de l'identifiant.

Pendant l'exécution, la connexion se fait automatiquement. Une fois connecté, le pilote prend en charge la fenêtre SAP ouverte sur la page d'accueil SAP.

‍

Session enregistrée dans les propriétés ATS

Pour rappel, il est également possible de configurer les applications couramment utilisées pour qu'elles apparaissent directement dans le panneau des applications lors de l'action d'ouverture de canal . Ceci est également possible pour les sessions auxquelles vous avez accès, y compris les sessions SAP.

Ce raccourci vous permet d'éviter de partager les informations relatives à la connexion à un serveur SAP (identifiants, mots de passe) si vous souhaitez travailler sur un test SAP sur plusieurs postes de travail.

‍

Pour utiliser ce raccourci, vous devez modifier les propriétés ATS .

Pour accéder aux propriétés ATS , allez dans la section "Paramètres" dans Agilitest.

Cliquez ensuite sur "Modifier la configuration" dans les paramètres de ATS

Cela ouvrira la page des propriétés ATS où vous pourrez configurer divers éléments.

‍

Voici un exemple de configuration possible pour une session SAP :

📙 Configuration SAP

<sap>

<timeOut>200</timeOut>

<sessions>

<session>

<name>MySAP</name>

<client>800</client>

<connection>(Logon_id)</connection>

<authentication>(Code_source_ATS)</authentication>

</session>

‍

L'authentification se trouve dans le code ATS de votre script avec une connexion SAP.

Pour y accéder, ouvrez votre script et cliquez sur l'icône "Données d'en-tête du script".

Cliquez ensuite sur "Code ATS"

Elle affiche toutes les actions du script sous forme de code.

Pour remplir les informations de connexion dans les propriétés, récupérez le code de chaîne correspondant à la connexion au serveur SAP à partir de l'action "Démarrer un canal".

Copiez les informations de connexion dans les propriétés ATS .

Une fois les informations saisies, sauvegardez votre fichier et revenez au menu des applications d'Agilitest où vous retrouverez la session que vous avez saisie.

‍

Interface SAP

Une fois SAP ouvert, tout comme un test sur le Web, vous pouvez capturer les éléments avec l'outil de capture pour pouvoir les tester.

‍

L'écran d'accueil SAP affiche les modules, ou transactions, disponibles pour les utilisateurs.

Ces modules correspondent à des programmes qui vous permettent de gérer différents aspects de l'entreprise, tels que la gestion des stocks ou les informations relatives aux ressources humaines.

Vous pourrez choisir parmi les différentes interfaces possibles en fonction des écrans qui ont été mis à votre disposition lors de la création de votre compte.

L'accessibilité de ces écrans est décidée en fonction du rôle occupé dans l'entreprise et de ses besoins en matière de gestion des données.

Les modules SAP permettent de gérer de nombreux aspects de l'entreprise tels que la finance, les ventes, la production, la logistique, la distribution, la comptabilité et les ressources humaines. Comme SAP gère un système d'information qui, par nature, est sujet à des changements, il est important d'effectuer régulièrement des tests unitaires fonctionnels dans votre processus QA pour s'assurer que tous ces processus fournissent continuellement les résultats escomptés.

Exemple: SAP propose une solution SIRH qui automatise les opérations de gestion des ressources humaines, mais qui offre également des expériences qui stimulent l'engagement et la productivité des employés. Le SIRH de SAP se concentre sur la gestion de l'expérience des employés, les fonctions de base des ressources humaines et de la paie, la gestion des talents et l'analyse des ressources humaines.

‍

Tests sur SAP

Changement de fenêtre

Dans certains cas, le module s'ouvre dans une nouvelle fenêtre SAP. Pour gérer cette notion de fenêtre, vous devrez changer la fenêtre d'Agilitest.

Pour ce faire, cliquez sur l'action de fenêtre.

Passez ensuite à la fenêtre ayant l'index 1 (la fenêtre principale a l'index 0).

‍

Actions sur un tableau

Une fois votre tableau ouvert dans l'interface SAP, ouvrez votre outil de capture pour effectuer des actions sur celui-ci.

Lors de la capture, vous devrez définir un Locator qui est un ensemble d'attributs permettant d'identifier l'élément capturé.

Parmi les branches parentales de l'élément, on trouve généralement : l'objet (Exemple:"TableControl", "GridControl", "TreeControl"), les lignes, les colonnes.

‍

Plusieurs cas de figure sont possibles :

• Recherche d'un élément d'un tableau qui apparaît directement sur l'interface

Exemple Un tableau de quelques lignes.

Lorsque nous capturons un élément sur l'écran, la recherche de l'élément avec le site locator sera moins précise.

La recherche peut être effectuée en fonction de l'attribut"Text" de l'élément capturé et de l'ElementId de la branche"TableControl".

Une fois les attributs sélectionnés, faites glisser l'élément dans l'éditeur Agilitest pour créer une action.

Ce type de recherche ne recherchera pas de ligne, mais restera simplement sur le même écran.

‍

• Recherche d'un élément de tableau dans une longue liste

Lorsque vous souhaitez capturer un élément d'une longue liste qui nécessite qu'Agilitest parcoure les éléments, vous devez le spécifier à l'aide d'attributs.

Cette fois, vous devez lui indiquer que l'élément se trouve dans une "Row"

Faire glisser l'élément dans une action

Une recherche dans une ligne est effectuée en fonction du texte qu'elle contient. Agilitest parcourt les lignes du tableau pour trouver celle qui contient le texte saisi comme attribut.

‍

💡 Conseil

Pour simplifier les opérations, il est recommandé de transformer le texte en une expression régulière.

‍

Actions sur les grilles

Il est possible de passer d'un tableau à une grille en appuyant sur la touche F8 et en spécifiant le nombre de lignes que l'on souhaite voir apparaître dans la case "Nombre maximum de lignes".

Les grilles permettent d'afficher plus d'informations qui peuvent être lues verticalement et horizontalement.

La capture d'un élément se déroule de la même manière que pour les tableaux, seul l'affichage des parents des éléments capturés spécifiera qu'il s'agit de grilles.

‍

Les grilles sont un ensemble de données organisées en lignes et en colonnes.

Il est également possible de rechercher la présence d'un élément dans plusieurs lignes en utilisant "Row".

Pour ce faire, vous devez créer un sous-script avec des commentaires de journal d'exécution pour afficher les éléments trouvés.

‍

Exemple: Si nous recherchons le texte "MIERZWA"dans toutes les lignes en utilisant la propriété text de la classe "GridRow", alors votre indice affichera les lignes qui contiennent ce texte.

Dans cet exemple, 5 itérations sont affichées, donc MIERZWA apparaît 5 fois dans les lignes. Les paramètres indiquent l'emplacement exact, par exemple la ligne "1014". (voir la capture d'écran ci-dessous)

Avec cette action, chaque ligne est transmise au script et chaque colonne représente un paramètre.

‍

Actions sur les arbres de données

L'arbre de données est parfois composé dans une configuration simple avec une seule colonne qui comprend plusieurs niveaux et d'autres fois de manière plus complexe, avec plusieurs colonnes dans le même arbre. L'exécution des tests sur les arbres est similaire à celle sur les grilles et les tableaux.

Les éléments de recherche d'un composant sont similaires à ceux des grilles et des tableaux.

La branche "TreeNode" représentera les nœuds de l'arbre, c'est-à-dire les différents niveaux qui apparaissent.

Chaque nœud a zéro ou n enfants qui peuvent être déployés.

Exemple: L'élément "Données de base" a 3 enfants, alors que ses enfants n'en ont aucun.

‍

Lorsqu'un arbre est complexe, un nœud peut avoir plusieurs colonnes.

Comme pour les grilles, l'arbre est configuré avec des lignes qui concatènent toutes les colonnes de la ligne.

Cela signifie que la recherche d'éléments d'une structure arborescente se fait principalement par le biais de la branche "Row".

‍

VBscript

Enregistreur SAP

L'une des fonctionnalités offertes par SAP est l'utilisation d'un enregistreur. Une fois activée, cette fonction enregistre les actions effectuées sur SAP et les traduit ensuite en vbscript.

Pour lancer la capture directement dans SAP, allez dans les options du menu déroulant : Plus > Options et actions SAP GUI > Enregistrement et playback du script

Une fenêtre de lancement s'affiche.

‍

Cliquez sur le bouton "enregistrer"pour lancer l'enregistrement

Une fois cela fait, effectuez vos manipulations puis cliquez sur le bouton "arrêter" pour terminer l'enregistrement.

Une fois la capture terminée, une page contenant toutes vos actions au format vbscript s'ouvrira automatiquement.

Pour rejouer ce script, cliquez sur le bouton "lecture".

‍

Cela ouvrira votre explorateur Windows et le dossier contenant votre script.

En cliquant sur le script, les actions qui ont été exécutées directement sur SAP seront exécutées à nouveau.

Pour utiliser les données vbscript dans Agilitest, vous devez consulter les dernières lignes de votre script.

‍

Action de script dans Agilitest

A partir d'Agilitest, vous pouvez également créer des actions au format vbscript et interagir avec SAP.

Deux possibilités s'offrent à vous :

1. Soit en utilisant les lignes de script du vbscript.

Pour cela, copiez une ligne de script de votre vbscript que vous souhaitez transformer en action.

Cliquez ensuite sur le bouton "Scripting"

Il n'est pas nécessaire de spécifier un élément d'interface.

Cliquez directement sur l'action "Scripting" et collez la ligne de script

‍

         2. Soit en créant manuellement des actions vbscript à l'aide des propriétés

Cliquez sur le bouton "Scripting".

Ajouter un élément d'interface et entrer une valeur qui agira sur cet élément

Exemple Exemple : Ci-dessus, l'élément interface correspond à un élément dans lequel on peut saisir du texte, avec l'élément "texte" de cet élément est définie comme "MIGO".

Lorsque l'action est exécutée, elle se traduit par le texte MIGO dans la saisie de texte sur SAP.

La différence entre ces deux manipulations est qu'en passant par une ligne de code du vbscirpt l'accès à l'objet se fait par son id, alors qu'en passant par une action Agilitest, l'accès à l'objet se fait par ses propriétés.

‍

Lorsque vous pouvez saisir du texte dans une action Agilitest, il est possible de cliquer sur un bouton qui vous permettra d'insérer des valeurs spéciales.

Cela vous montrera toutes les valeurs spéciales organisées dans un menu dédié.

Parmi ces valeurs spéciales se trouvent :

‍

Variable d'environnement

Les variables d'environnement sont liées à l'exécution en cours.

Elles se trouvent dans les variables d'exécution dans le constructeur de projet.

Pour y accéder, cliquez sur "Gestion des exécutions".

Cela ouvrira la page du constructeur de projet où vous pouvez trouver les variables d'environnement dans l'encart des valeurs spéciales.

Vous trouverez les mêmes informations sur les variables d'environnement dans le menu des valeurs spéciales.

‍

Variable de script

Les variables de script correspondent aux variables déclarées dans un script.

Dans l'éditeur, ils se trouvent dans la partie dédiée aux variables sous l'explorateur de projet.

Vous trouverez les mêmes informations sur les variables de script dans le menu des valeurs spéciales.

‍

Paramètre de script

Les paramètres de script sont les paramètres qui sont passés dans un appel de sous-script.

Ils se trouvent à l'intérieur de l'action d'appel du sous-script, dans les paramètres ajoutés.

Vous trouverez les mêmes informations sur les paramètres de script dans le menu des valeurs spéciales.

‍

Assets

Le fichier des assets correspond au chemin de tous les fichiers qui se trouvent dans les assets (Exemple: données, ressources, etc...). Cela correspond au chemin relatif emprunté par ces fichiers.

Les valeurs se trouvent dans l'explorateur de projet, dans le dossier"Assets".

Vous pouvez trouver les mêmes informations sur le fichier des actifs dans le menu des valeurs spéciales.

‍

Mots de passe

Les mots de passe correspondent à tous les mots de passe saisis dans un projet.

Ils peuvent être trouvés dans la page des propriétés du projet.

Pour accéder aux propriétés, cliquez sur "Propriétés du projet"dans l'explorateur de projet

Dans les propriétés, vous avez accès aux mots de passe créés.

Vous trouverez les mêmes informations sur les mots de passe dans le menu des valeurs spéciales.

‍

Valeurs de canal

Ces valeurs correspondent aux valeurs renvoyées par un canal en cours d'exécution.

Exemple :

Dans un script qui ouvre un canal "Chrome",

Si nous demandons à récupérer la valeur du "Nom de l'application" dans les valeurs spéciales,

Alors, le nom de l'application ouverte par le canal apparaîtra.

‍

🔸 Avertissement

Si le canal n'est pas lancé, la valeur ne peut pas être récupérée.

‍

Valeurs de script ATS

Les valeurs de script ATS sont des valeurs qui ne sont valorisées que dans une exécution Java. Elles n'apparaissent que lorsqu'elles sont extraites du Top script dans une exécution Java.

Valeurs calculées

Les valeurs calculées sont résumées dans un menu déroulant.

Ces valeurs sont : Maintenant, Aujourd'hui, Identifiant unique, Caractère aléatoire, Itération en cours, Nombre d'itérations.

‍

‍

Mobile Station permet de réaliser des tests sur mobile (USB et Wifi) et sur tablette (USB) via ATS ou directement via Agilitest.

Configurer un serveur Mobile Station

Comment configurer Mobile Station afin qu'Agilitest puisse discuter directement avec Mobile Station ?

Retrouvez une vidéo montrant les étapes pour connecter un serveur Mobile Station à Agilitest en regardant ce tutoriel : https://youtu.be/-SE1kN03LMw (configurer un serveur Mobile Station)

‍

Connexion à un serveur

Pour vous connecter à un serveur, vous devez vous rendre dans les paramètres d'Agilitest en cliquant sur "Paramètres" en haut à droite de l'écran.

‍

Dans le cadre "ATS Mobile Station server", vous pouvez ajouter un serveur que vous connecterez à Agilitest en cliquant sur "Ajouter".

‍

Il vous sera demandé de saisir l'adresse IP et le port, qui seront récupérés directement dans l'interface Mobile Station.

‍

Pressez la touche "Entrer" pour confirmer votre sélection et le serveur apparaîtra sur une nouvelle ligne dans l'encart Mobile Station.

Cliquez sur le serveur pour afficher les détails et pouvoir modifier l'adresse IP et le port.

‍

Connecter Agilitest à un mobile

Il existe une connexion entre Mobile Station et Agilitest qui permet à Agilitest de savoir quels appareils (y compris les tablettes) sont connectés à Mobile Station.

Une fois que le serveur Mobile Station est configuré, ouvrez un nouveau canal.

‍

Ensuite, sélectionnez "Application mobile" dans le choix des applications (icône du téléphone dans le coin supérieur droit).

‍

Agilitest ouvrira une pop-up pour entrer l'adresse IP et le port du téléphone. Vous pouvez les entrer manuellement, ou sélectionner un serveur connecté à Mobile Station, comme présenté ci-dessus.

Entrez l'adresse IP du téléphone ou sélectionnez un serveur.

‍

Cliquez sur le bouton "Découvrir" pour ouvrir la fenêtre mobile et ses applications.

‍

Celui-ci affichera les applications installées dans le téléphone ainsi qu'un ensemble d'informations accompagnées d'un visuel de téléphone qui n'est pas forcément représentatif de son apparence réelle mais qui a pour but de différencier un Android d'un iOS.

Dans la liste des applications du téléphone, sélectionnez celle que vous voulez tester, puis cliquez sur "Ok".

‍

Une fois que vous avez fait cela, vous pourrez voir que le canal a été modifié avec les nouvelles informations, puis cliquez sur le bouton exécuter pour ouvrir l'application.

‍

Utilisation unique de Mobile Station

Du côté MobileStation, vous verrez un cadenas apparaître à côté du mobile dans lequel les actions sont exécutées. Cela signifie que ce mobile est lié à cet ordinateur utilisant Agilitest, donc si une autre personne utilise Agilitest sur un autre ordinateur et souhaiterait utiliser ce mobile un message d'erreur apparaîtra pour informer que le téléphone est déjà utilisé.

‍

Pour libérer le téléphone et arrêter son utilisation dans Agilitest, il suffit de fermer le canal de votre script.

‍

‍

‍

Exécution Mobile Station

Mobile Station vous permet d'exécuter des tests sur des appareils mobiles et des tablettes via ATS ou directement via Agilitest. Les tests peuvent être effectués sur Windows, où seul Android peut être exécuté, ou sur MAC où il est possible d'exécuter à la fois Android et iOS. Il existe deux façons de se connecter aux appareils mobiles :

• Par connexion Wifi, sauf pour les appareils iOS et les tablettes.
• Par connexion USB

Voici un schéma montrant le système d'exécution Mobile Station

‍

Ouvrir une application mobile

Voici un exemple de test mobile exécuté sur un MAC. Agilitest est ouvert avec un script déjà rempli et Mobilestation fonctionne avec un Iphone branché.

La procédure de test suit les mêmes principes qu'un test Web.

Tout d'abord, ouvrez un canal,

‍

Lorsque vous souhaitez utiliser l'outil de capture, un rendu visuel de votre téléphone s'ouvre sur votre écran.

Capture d'un élément

Pour capturer un élément, le système est le même que pour les autres formes de tests (web, desktop, etc...).

Appuyez sur la touche CTRL de votre clavier pour ouvrir la fenêtre parent de l'élément capturé et de ses attributs.

‍

Lorsque la capture est ouverte, il est également possible d'interagir directement sur les éléments de l'application en appuyant sur la touche Shift de votre clavier.

Boutons spécifiques à Mobile Station

Les tests mobiles sont très similaires aux tests effectués sur d'autres applications. Toutefois, deux boutons sont spécifiques à Mobile Station :

• Bouton "Accueil"

Il apparaît au centre, en bas du visuel du téléphone. Il sert de bouton d'accueil que l'on trouve sur les téléphones physiques. En cliquant dessus, la page d'accueil du téléphone apparaît.

‍

• Bouton "Rafraîchir"

Il apparaît en haut du visuel du téléphone. Ce bouton sert à réinitialiser la capture si elle rencontre des problèmes. Il est utilisé pour renforcer la mise à jour.

‍

‍

Mobile Station et Intégration Continue

L'intégration continue permet le déploiement d'une application mobile développée en dehors de Mobile Station via une API Rest.

L'application est envoyée à la Mobile Station à l'aide d'une Rest API. La Mobile Station l'installe ensuite sur les appareils afin que l'application puisse être exécutée et testée avec un script ATS via USB ou WiFi.

Il existe trois stratégies différentes pour mettre en œuvre l'intégration continue :

‍

Stratégies de mise en œuvre de l'intégration continue

1. L'intégration continue du testeur lance l'intégration continue du développeur d'applications

‍

Avec son intégration continue, le concepteur de tests déclenche l'intégration continue du développeur d'applications qui va générer une application à partir du code source. Cette application sera envoyée à Mobile Station qui l'installera sur les appareils afin de la rendre disponible pour les tests. (Lien vers la vidéo du schéma animé : https://youtu.be/ISN874CZxxI)

‍

       2. L'intégration continue du développeur d'applications lance l'intégration continue du testeur

‍

L'intégration continue du développeur de l'application va générer l'application à partir du code source. Elle sera ensuite envoyée à la Station Mobile et installée sur les appareils. Avec l'intervention de l'intégration continue du développeur de tests, les tests seront générés via le code source ce qui permettra l'exécution des tests depuis la Mobile Station. (Lien vers la vidéo du schéma animé : https://youtu.be/5ui7ZPKnOKQ)

‍

       3. Le développeur de l'application et le testeur travaillent de manière asynchrone.

Le développeur d'applications et le concepteur de tests peuvent exécuter leurs tests de manière asynchrone. Avec son intégration continue, le développeur d'applications installera son application sur ses appareils via la Mobile Station. Avec l'intégration continue du concepteur de tests, l'application installée sur la Mobile Station et sur ses appareils peut être testée. (Lien vers la vidéo du schéma animé : https://youtu.be/CyMW2N2tjiE)

‍

Qu'est-ce que Bitbucket ?  

Bitbucket est un service proposé par la société Atlassian, qui permet d'héberger et de versionner des fichiers à l'aide des technologies suivantes Git. Il est bien connu dans le monde de l'entreprise, facile à utiliser, et permet une intégration parfaite avec Jira, un système de suivi bug développé par la même société mère.
La gestion des dépôts Git se fait à partir de l'interface web du service SaaS, mais un logiciel de bureau est disponible pour effectuer les opérations de mise à disposition et de livraison des fichiers. Il s'agit de Sourcetree.
Pour les besoins de cet article, le logiciel Sourcetree logiciel a été configuré en anglais pour plus de clarté sur les termes originaux de Git : Stage, Commit, Pull, Push, Fetch, Branch, Merge, Stash. Par ailleurs, tous les termes de l'application ne sont pas traduits de l'anglais.

Pour les besoins de cet article, il est donc nécessaire de disposer d'un compte utilisateur Bitbucket, et du logiciel Sourcetree en mode connecté. La connexion de Sourcetree avec le compte Bitbucket peut se faire via les identifiants de connexion, ou via des jetons d'API qui sont créés sur le back-office Bitbucket dans Paramètres personnels > Mots de passe de l'application > Créer des mots de passe de l'application.
SourceTree a été configuré pour utiliser l'installation "système" de Git et non la version intégrée qui peut parfois causer des problèmes d'authentification pour les clones de référentiel.

Mise en place d'un projet Agilitest géré avec Git  

La première étape consiste à créer un dépôt Git depuis l'interface web de Bitbucket ou depuis le logiciel Sourcetree en mode connecté.

Créer un référentiel vide  

Depuis le logiciel, allez dans l'onglet Local, cliquez sur le bouton Créer.
Saisissez le chemin d'un dossier vide destiné à contenir le référentiel sur le disque dur local, ainsi que le nom du référentiel (ici référentiel-test). Cochez "Create Repository On Account " et sélectionnez le compte Bitbucket sur lequel synchroniser le référentiel (Account, Owner, Description). Cochez"Is Private" pour éviter de publier votre contenu en open-source à la vue de tous.  

Mise en place d'un projet Agilitest dans le référentiel  

En fonctionnement local, sans Git, Agilitest vous permet de créer de nouveaux projets. Ces projets sont alimentés automatiquement avec une arborescence par défaut qui comprend les libs, src, target, etc.  

Mais dans ce cas, nous avons commencé par créer le dossier vide du projet (pour en faire un référentiel). Nous devons donc copier les éléments d'un projet vide dans notre dossier de référentiel Git (ici, référentiel-test). Une façon de le faire est de créer le projet repository-rest-2 dans Agilitest et de copier et coller son contenu dans repository-test. Faites attention cependant à mettre à jour les fichiers README.md, .atsProjectProperties, et pom.xml pour adapter le nom correct du projet.

Une autre façon est de créer d'abord le projet Agilitest, de déplacer son contenu ailleurs, d'initialiser le dépôt Git, de remettre son contenu, puis de Stage et Commit le dépôt.

Premier engagement  

À cette étape, nous sommes au niveau zéro du projet et prêts à commencer. Il est temps de s'engager.  

Pour ce faire, allez à Sourcetree : Unstaged files > Stage all puis cliquez sur le bouton Commit en bas à droite. Veillez à ne pas confondre ce bouton avec celui qui se trouve en haut à gauche.

Le projet est donc "instantané" dans son état initial et, dans le futur, il sera possible de revenir à cet état. Pour synchroniser le dépôt et ses commits sur le serveur Bitbucket, cliquez sur l'icône"Push".  

Une question qui revient souvent est de savoir à quelle fréquence il faut commiter. Pour répondre à cette question, voyons la notion de commits atomiques, qu'il est conseillé de respecter :  

• Un commit ne concerne qu'une seule tâche : un test maintenance, une évolution d'un test ATS , un nouveau scénario ATS , etc.  
• Un commit ne rompt pas la cohérence du référentiel en empêchant l'exécution des tests ou de la campagne.  
• Un commit doit être associé à un message concis et explicite.

Possibilités offertes par cette configuration  

Les possibilités offertes par ce dépôt Git Bitbucket sont les mêmes que pour tout dépôt Git :  

• Versioning des projets Agilitest et en particulier des fichiers .ats .  
• Le travail collaboratif entre plusieurs profils d'automatisation sur un même projet, et en particulier la notion de Fusion.  
• Synchronisation des dossiers du projet entre le référentiel Git, les rôles d'automatisation et le serveur d'exécution. Git est donc un pilier de la chaîne CI/CD.  

Notez que la conservation des rapports est généralement gérée par Jenkins, avec la conservation des artefacts de chaque lancement de tâche (#1, #2 etc), plutôt que par le versionnement des fichiers de rapport d'exécution.

‍

Dans ce guide, nous allons expliquer comment utiliser un projet d'un dépôt Git comme source de projet Agilitest pour exécuter des tâches Jenkins. À chaque construction, Jenkins effectuera d'abord le Clone du dépôt Git, puis procédera à l'exécution des scripts ATS configurés dans la suite de tests, et enfin générera les rapports éventuels.  

Préparation du projet Agilitest  

Pour les besoins de ce guide, le dépôt Git est hébergé chez Bitbucket et a été initialisé avec un nouveau projet Agilitest vide en suivant les étapes de la documentation Configuration d'un dépôt Git hébergé par Bitbucket pour les projets Agilitest.  

Ensuite, le projet Agilitest (ici, repository-test) a vécu à travers les commits, avec l'accumulation de ATS scripts, de suites de tests et de fichiers de données.  

Création de la tâche Jenkins  

Le serveur Jenkins doit être démarré et connecté à Agilitest depuis le menu Outils. Il peut s'agir d'un serveur Jenkins local installé par Agilitest, ou d'un serveur distant géré par votre administrateur.  

Il est alors temps de créer un nouveau job Jenkins à partir du menu d'exécution d'Agilitest (en cliquant sur le bouton "Gérer les suites d'exécution du projet" dans la zone en accordéon"Explorateur de projets").

Passez ensuite en mode "Intégration Jenkins" et cliquez sur"Créer une nouvelle tâche". Notez qu'Agilitest a déjà reconnu la présence d'un dépôt Git dans le dossier du projet avec son sous-dossier .git caché. Dans notre exemple, nous laissons la branche */master par défaut. Ensuite nous glissons et déposons la suite de test désirée dans la zone "Liste des Suites".

Après validation, le nouveau job Jenkins apparaît dans Agilitest comme ceci.

Avant de lancer le build, il est essentiel de préparer le projet Agilitest à supporter les opérations Push et Fetch qui seront effectuées respectivement par le client Git et le serveur Jenkins. L'opération par défaut de Git n'est pas de synchroniser les dossiers vides, pourtant certains d'entre eux sont essentiels à Agilitest. Une solution de contournement consiste à déposer un fichier .gitkeep vide dans chaque dossier vide du projet Agilitest. Ces fichiers forceront Git à synchroniser les dossiers (vides) qui les contiennent.

• ./target/ats-output/.gitkeep
• ./target/classes/assets/ressources/lang/.gitkeep
• ./target/classes/assets/resources/certs/.gitkeep
• ./target/classes/assets/ressources/images/.gitkeep
• ./target/classes/assets/data/.gitkeep
• ./target/report/.gitkeep
• ./libs/.gitkeep
• ./src/main/java/.gitkeep
• ./src/main/scripts/.gitkeep
• ./src/main/ats/subscripts/.gitkeep
• ./src/assets/data/.gitkeep
• ./src/assets/resources/lang/.gitkeep
• ./src/assets/resources/certs/.gitkeep
• ./src/assets/resources/images/.gitkeep

Configuration de Jenkins  

Tout d'abord, Git doit être installé sur la machine qui exécute Jenkins. Le serveur Jenkins doit avoir le fichier Plugin Git. Ensuite, l'exécutable git.exe doit être configuré dans le répertoire de Jenkins. Manage Jenkins > Global Tool Configuration > Git > Path to Git executable. Dans ce cas, nous avons défini C:\Program Files\Git\bin\git.exe.

Voyons à quoi ressemble la tâche Jenkins nouvellement créée dans le projet de référentiel de test depuis le back-office web.

L'URL du dépôt Git est reconnue. Il est important de configurer l'authentification au dépôt Git dans Jenkins. Ici, nous avons utilisé un compte Bitbucket (paul-chevalier) et un jeton API créé à partir du menu "App passwords" dans l'interface d'administration de Bitbucket.

On peut initialiser le dépôt Git dans SourceTree avec la syntaxe https://paul-chevalier:my-app-password@bitbucket.org/paul-chevalier/repository-test.git. Le mot de passe de l'application figure dans l'URL, donc dans ce cas, il n'est pas nécessaire de configurer les informations d'identification dans Jenkins. Pour ce faire, SourceTree peut avoir besoin d'adresser le System git.exe au lieu du Embedded gitlib.

Lancement d'une construction  

Lors du lancement d'un build sur le job Jenkins ainsi configuré, vous pouvez suivre l'opération de Clone du dépôt Git orchestré par Jenkins dans la sortie standard(icône SortieConsole). Le nom du dernier commit apparaît ici.

Building in workspace
C:\Users\paulc\.agilitest\work\jenkins\workspace\job\com.functional.repository-test\newJobJenkins
[…]
Fetching changes from the remote Git repository
>C:\Program Files\Git\bin\git.exe config remote.origin.url https://paul-chevalier@bitbucket.org/paul-chevalier/repository-test.git # timeout=10
Fetching upstream changes from https://paul-chevalier@bitbucket.org/paul-chevalier/repository-test.git
[…]
>C:\Program Files\Git\bin\git.exe fetch --tags --force --progress -- https://paul-chevalier@bitbucket.org/paul-chevalier/repository-test.git +refs/heads/*:refs/remotes/origin/* # timeout=10
>C:\Program Files\Git\bin\git.exe rev-parse"refs/remotes/origin/master^{commit}" # timeout=10
Checking out Revision f167510d99abb5af2674db52227860cf423869fa(refs/remotes/origin/master)
>C:\Program Files\Git\bin\git.exe config core.sparsecheckout #timeout=10
>C:\Program Files\Git\bin\git.exe checkout -ff167510d99abb5af2674db52227860cf423869fa # timeout=10
Commit message: "Ajout de fichiers .copy manquants"
[…]

‍

En outre, un nouveau menu Git apparaît sur la page Jenkins pour la construction (ici #5).  

A travers cet article et ses pré-requis, nous avons utilisé Git pour relier les postes de travail de l'ingénieur d'automatisation des tests qui utilisent Agilitest et le serveur Jenkins. Notre chaîne d'intégration continue est prête !

‍

Dans ce guide, nous allons présenter une méthode étape par étape pour exécuter des tests Agilitest massifs.

Contexte général  

Le serveur Windows  

Dans le cadre de ce guide, nous avons installé un serveur Windows 2016. Il s'agit d'une version d'entreprise courante, mais la version 2019 fonctionne également, car toutes deux partagent le même noyau que Windows 10.

Ce serveur est une VM virtualisée avec Linux KVM, et le serveur hyperviseur lui-même est hébergé dans un centre de données. Toutes les opérations de configuration se font via le Bureau à distance avec le protocole RDP.  

Lors de l'installation, il est nécessaire de vérifier la version" Windows Server 2016 Standard (User Experience) " avec un environnement graphique. D'abord pour faciliter les opérations d'administration, mais surtout parce que la plupart des tests ATS générés avec Agilitest nécessitent un environnement de bureau.

Deux comptes d'utilisateur ont été créés : worker1 et worker2.  

Installation d'Agilitest  

Agilitest a été installé sur le serveur depuis la session Administrateur dans le dossier C:\Program Files (x86\Agilitest. Cette installation est globale pour tous les utilisateurs, et chacun trouvera un raccourci Agilitest sur son bureau.
Par contre, les dépendances et les fichiers de configuration sont spécifiques à chaque utilisateur concernant les deux dossiers ci-dessous :  

• C:\Users\Administrator\.actiontestscript  
• C:\Users\Administrator\.agilitest
  

Les mêmes dossiers seront créés pour les utilisateurs worker1 et worker2 automatiquement, lors du premier build Jenkins. Il est donc possible d'avoir une configuration particulière du logiciel pour chaque utilisateur. Par exemple, il est possible de modifier la version du navigateur Chrome ou Firefox qui sera utilisée par l'utilisateur worker1 en modifiant le fichier C:\Users\worker1\.actiontestscript\.atsProperties.

Vous pouvez trouver plus d'informations sur la page officielle actiontestscript sur GitHub.  

Installation de Jenkins  

Ligne de commande du service ou de l'utilisateur  

Ici, Jenkins a été installé à partir du programme d'installation .msi pour Windows. Cet installateur propose de configurer un service Windows indépendant, ce que nous avons fait (Type de connexion : exécuter le service en tant qu'utilisateur local ou de domaine) avec l'utilisateur Administrateur.

Il est intéressant de noter que le paquet Java jenkins.war peut ensuite être exécuté en tant que service ou en tant que ligne de commande à partir d'une session utilisateur avec l'environnement de bureau.

Il est également important de mentionner que la façon dont Jenkins est lancé aura des implications sur les builds ATS qui sont exécutés. En mode service, l'exécution d'un test (par exemple le navigateur web Chrome canal) ne génère aucune fenêtre visible sur la session utilisateur, qui peut être fermée ou verrouillée, mais les captures d'écran ATSV seront vides. En mode ligne de commande à partir d'une session utilisateur avec un environnement de bureau, le test générera des fenêtres visibles sur la session utilisateur, et les captures d'écran ATSV fonctionneront.

Quoi qu'il en soit, il est recommandé d'exécuter Jenkins en tant que service, et d'exécuter des suites de tests avec des agents Jenkins dans des sessions utilisateur avec des environnements de bureau. L'agent Jenkins peut être déclaré à l'ouverture de la session avec shell:startup.

Un tutoriel en anglais sur l'autorisation d'un compte utilisateur à exécuter un exécutable en tant que service est disponible ici. Les étapes à suivre sont les suivantes : Outils d'administration > Politique de sécurité locale > Stratégies locales > Attribution des droits d'utilisateur > Ouverture de session en tant que service (NT SERVICE\ALL SERVICES). L'utilisateur Administrateur a été ajouté ici.

Le chemin vers le Java JDK est demandé par le programme d'installation. Java 52 (Java 8) ou 55 (Java 11) sont recommandés par défaut mais il est possible d'utiliser Java JDK 15 en ajoutant l'argument - enable-future-java dans le fichier de configuration Jenkins.xml.

La première connexion au back-office web de Jenkins nécessite la saisie d'un mot de passe contenu dans un fichier texte. Nous avons ensuite installé les plugins recommandés.

À ce stade, le gestionnaire de services Windows doit permettre de démarrer et d'arrêter le service Jenkins. Le type de démarrage automatique permet au service de démarrer dès que le serveur est lancé, avant même qu'un utilisateur ne se connecte.

L'installation de Jenkins a été configurée avec les points suivants :

• Installation de l'extension Locale pour forcer la langue "en" quelle que soit la langue demandée par le navigateur.  
• Installation des extensions Jenkins suivantes : TestNG Results Plugin & Test Results Analyzer  
• Configurer le chemin vers git.exe (voir l'article Utiliser un dépôt Git comme source de projet Agilitest pour les constructions Jenkins)
• Ajouter l'étiquette ats-executor dans le menu Manage Jenkins > Manage Nodes and Clouds > Built-In Node > Configure.
  

Dans ce type de configuration, prenez soin d'effectuer un Commit puis un Push de votre projet Agilitest afin que Jenkins puisse exécuter vos mises à jour.

Dans AWS, une instance est une VM (Virtual Machine), un conteneur, etc. Dans notre cas, l'instance sera une VM.

Créer une instance pour Agilitest/Jenkins dans le nuage AWS.

Pour créer votre instance, vous allez passer par 7 étapes. Pour commencer à créer une instance, cliquez sur "lancer l'instance".

Étape 1 : Choisissez votre image

Agilitest a besoin d'une distribution Windows. Dans la barre de recherche, entrez "Windows 2016" et sélectionnez l'image "Microsoft Windows Server 2016 Base".

Étape 2 : Choisir le type d'instance

Pour le choix du type d'instance, un type t2.small suffira. Cependant, pour plus de confort, il est recommandé d'utiliser un type t2.large ou plus grand.

Après avoir sélectionné le type d'instance que vous souhaitez utiliser, cliquez sur "suivant".

Étape 3 : Configurer l'instance

Pour cette étape, aucun changement n'est nécessaire pour faire fonctionner l'instance. Vous pouvez passer à l'étape suivante.

Étape 4 : Stockage

La configuration par défaut est suffisante pour notre instance. Vous pouvez passer à l'étape suivante.

Étape 5 : Étiquettes

Cette étape facilite la lecture de votre liste d'instances. Il n'est pas nécessaire d'ajouter des balises mais cela simplifiera votre lecture.

Étape 6 : Configuration du groupe de sécurité

Tout d'abord, vous devrez créer un groupe de sécurité. Le nom et la description sont ouverts, à vous de remplir les informations en fonction de votre configuration.
Le champ type vous permet de choisir avec quel protocole vous allez vous connecter à votre instance. Le choix d'une connexion avec le protocole RDP est simple et parfaitement fonctionnel.
Aucune modification n'est nécessaire sur le protocole et le ciblage des ports.
Dans la partie source, choisissez "Mon IP" afin que seule votre machine puisse accéder à votre instance. Si vous avez besoin d'y accéder via une autre adresse IP, vous pouvez ajouter une nouvelle règle "personnalisée" avec l'adresse IP de la machine à laquelle vous voulez accéder.

Une fois que c'est fait, vous devrez cliquer sur "revoir et lancer".

Étape 7 : Lancer l'instance et créer la clé d'accès

Cliquez sur "lancer", une fenêtre s'ouvre pour sélectionner ou créer une paire de clés. Si vous avez déjà une paire de clés, sélectionnez-la. Si vous n'en avez pas, sélectionnez "create a new key pair". Donnez-lui un nom et téléchargez-la.
Attention, vous devez sauvegarder votre clé ou vous ne pourrez pas accéder à votre instance. Vous pouvez maintenant lancer votre instance.

Se connecter à l'instance

Maintenant que votre instance a été créée, vous devez vous y connecter. Pour ce faire, cliquez sur votre instance une fois qu'elle a démarré, puis cliquez sur "connecter". Vous arrivez sur la fenêtre de connexion de votre instance.

Vous devrez d'abord cliquer sur "obtenir le mot de passe" pour obtenir votre mot de passe.

Ici, vous devrez obtenir la clé téléchargée à l'étape 7 via "Browse" et ensuite décrypter cette clé pour obtenir votre mot de passe.
Votre mot de passe ne changera pas d'une connexion à l'autre, même si vous arrêtez votre instance. Pensez donc à noter votre mot de passe pour ne pas avoir à répéter cette étape.
Vous pouvez maintenant télécharger votre bureau à distance et vous y connecter avec votre mot de passe.

Installation d'Agilitest

Une fois que votre instance a été créée et que vous vous êtes connecté, vous devrez installer Agilitest.
Tout d'abord, téléchargez Agilitest et JDK 10 (requis pour Jenkins). Ensuite, lancez Agilitest depuis les paramètres et téléchargez les paramètres de ATS et les paramètres de java (JDK). Allez ensuite sur Outils et téléchargez Jasper, Maven et Jenkins (version serveur embarquée).
Si vous avez un Git, vous pouvez le lier à votre Agilitest. Pour ce faire, allez dans "settings", et cliquez sur ajouter dans le compte git.

Installation de Jenkins

Pour finir, vous devez vous connecter à votre Jenkins. Cliquez sur "connecter" puis connectez-vous localement via un navigateur à l'adresse localhost:port
Dans Jenkins, allez à Gérer Jenkins > Configuration globale de l'outil et installez le JDK 10.
En option, toujours dans Manage Jenkins > Configure system, vous pouvez ajouter votre serveur github pour pouvoir rejouer vos tests. Cependant, vous devrez également lier votre github à Agilitest. Vous pouvez le faire directement dans les paramètres d'Agilitest.

Votre instance avec Agilitest est maintenant prête à effectuer vos premiers tests.

‍

Pour fonctionner, Azure Pipeline s'appuie sur deux types d'agents :

• Hébergé par Microsoft : Les agents sont hébergés sur Microsoft Cloud et de nombreuses plateformes sont proposées. Pour plus d'informations : https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/hosted?view=azure-devops
• Auto-hébergé : Vous pouvez télécharger le programme d'installation de l'agent et l'héberger vous-même sur l'environnement de votre choix. Pour plus d'informations :https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/agents?view=azure-devops&tabs=browser#install
  Nous utilisons des agents auto-hébergés et c'est la solution qui sera décrite dans cet article. Cependant, il est certainement possible d'adapter les informations ci-dessous si vous souhaitez utiliser des agents hébergés sur le Microsoft Cloud.

1. Mise en place de l'environnement

Vous pouvez installer l'agent Azure Pipeline sur une machine Linux, MacOS, Windows ou Docker. Dans cet article, nous allons détailler les étapes pour utiliser un agent sur une machine Windows 10. Vous pouvez vous référer à la documentation de Microsoft pour les spécificités des autres plateformes.

Comment télécharger et installer l'agent

Pour commencer, connectez-vous à Azure DevOps et cliquez sur User settings, puis sur Personal access tokens:

• Créez un nouveau jeton en sélectionnant l'autorisation Pools d'agents (lecture, gestion).
• Revenez à la page d'accueil d'Azure DevOps et cliquez sur Organization settings en bas à gauche.
• Cliquez sur Pools d'agents et sélectionnez le pool par défaut ou créez un nouveau pool auto-hébergé.
• Cliquez sur Nouvel agent et suivez les instructions de la page pour télécharger votre agent.
• Dézippez l'archive téléchargée sur la machine où vous voulez installer l'agent et exécutez config.cmd.
• Suivez le script pour configurer votre agent, y compris le jeton créé précédemment. Lorsque vous avez le choix entre un mode interactif ou en tant que service, choisissez le mode interactif sinon vous ne pourrez pas lancer les tests ATS .
• Une fois que votre agent est configuré, exécutez exécuter.cmd pour le démarrer.
• Pour plus d'informations sur le téléchargement et l'installation d'un agent Azure Pipeline : https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/v2-windows?view=azure-devops.

Réglage de la machine

Une fois l'agent installé, plusieurs éléments sont nécessaires au bon fonctionnement des tests ATS :

• Le dossier .actiontestscript : ce dossier doit être présent à la racine du dossier de l'utilisateur qui exécutera l'agent. Il est créé automatiquement et mis à jour lors du lancement d'Agilitest. Si vous ne souhaitez pas installer Agilitest sur la machine où l'agent est installé, vous pouvez copier et coller ce dossier depuis un autre ordinateur où Agilitest est installé. Dans le futur, il sera possible de mettre à jour ce dossier via npm et de l'automatiser dans le pipeline.
• Le JDK doit être installé. Actuellement Agilitest a besoin de JDK version 11 ou plus.
• Maven doit également être installé, vous pouvez le télécharger ici : https://maven.apache.org/download.cgi.

‍

2. Créer un nouveau pipeline sur Azure DevOps

Sur Azure DevOps, cliquez sur le menu Pipelines :

Cliquez ensuite sur Nouveau pipeline et indiquez où se trouve le code de votre projet Agilitest et suivez les instructions pour y connecter le pipeline Azure.

‍

‍

Vous pouvez choisir d'utiliser un pipeline préconfiguré pour Maven.

La sélection d'un projet maven permettra à AzuredevOps de gérer directement les dépendances et les bibliothèques externes requises.

• Vous pouvez également démarrer à partir d'un pipeline vide et ajouter une tâche Maven.
• Dans la section pool, changez le type "vmImage" en "name" et entrez le nom du pool que vous avez créé plus tôt.
• Modifiez la tâche Maven :
  o Changez la valeur de "goals" en "clean test"
  o Changez la valeur de "javaHomeOption" en "Path"
  o Ajoutez une propriété "jdkDirectory" et spécifiez le chemin vers le JDK sur votre machine
  o Supprimez les propriétés "jdkVersionOption" et "jdkArchitectureOption". et "jdkArchitectureOption"
  o Ajoutez une propriété "mavenVersionOption" avec la valeur "Path"
  o Ajoutez une propriété "mavenDirectory" et spécifiez le chemin de Maven sur votre machine
  o Ajoutez une propriété "mavenSetM2Home" avec la valeur "true".
• Votre fichier YAML devrait ressembler à ceci :

‍

Pour plus d'informations sur la tâche Maven : https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/build/maven?view=azure-devops

Si vous cliquez sur Save and run, le fichier YAML sera ajouté à votre code source et vos tests seront exécutés selon la configuration de votre fichier pom.xml.

De la configuration d'Agilitest à l'utilisation de ses fonctionnalités les plus avancées, notre documentation couvre le plus large éventail de sujets.

Si vous ne trouvez pas ici les réponses à vos questions sur Agilitest, n'hésitez pas à contacter notre équipe d'assistance.

AGILITEST est une application client fonctionnant sur les systèmes d'exploitation Windows.

Systèmes pris en charge :

• Windows Server 2016
• Windows 10 au moins

Besoins en logiciels

Les logiciels suivants sont nécessaires au bon fonctionnement de la solution AGILITEST.

• Installation du Java JDK 11 au moins recommandée (Jdk 15 peut être installé automatiquement par Agilitest)
• Installation du .NET Framework 4.8
• Navigateurs : prise en charge des dernières versions des navigateurs et des versions relativement récentes pour lesquelles il existe un pilote Web. Une version spécifique peut être configurée par défaut.
• Chrome
• Chromium / JXBrowser
• Firefox
• Microsoft Edge
• Microsoft NewEdge
• Opéra
• Internet Explorer : V11 supportée / uniquement les dernières versions (nous contacter).

Android

Agilitest supporte les versions récentes d'Android > 5.0.

Prise en charge des mobiles physiques.

Support des émulateurs (Android Studio, Genymotion...)

iOS

Agilitest supporte les versions récentes d'iOS> v12.

Prise en charge des mobiles physiques.

Prise en charge des émulateurs.

Exigences matérielles

Ordinateur personnel :

Le matériel minimum recommandé pour l'utilisation d'AGILITEST sur votre ordinateur client est le même que pour le .NET Framework 4.8.

• Processeur : 2 GHz au moins
• Mémoire : 16 Go

Installation globale : environ 300 Mo d'espace disque sont nécessaires.

• Java JDK : 250 Mo
• Apache Maven : 10 Mo
• Bibliothèques de sélénium + ATS : 10 Mo
• Conducteurs de sélénium : 26 Mo
• Adobe Air : 10 Mo

Écran :

Une bonne résolution d'écran est nécessaire, au moins 1280x1024, afin de visualiser l'application sans défilement, ou avec un défilement limité et Agilitest dans le même écran.

Deux écrans sont indispensables si vous avez l'intention d'utiliser Agilitest au quotidien, un écran pour Agilitest et un écran pour l'application testée.

Réseau et applications

Mise à jour de l'Agilitest :

Afin de mettre régulièrement à jour votre version d'agilitest, vous devrez disposer d'un accès réseau complet à ces sites :

https://api-agilitest.com

https://caipture.com

www.actiontestscript.com

Les accès se font sur les ports 80 et 443.

Si ce n'est pas ou partiellement le cas, veuillez nous contacter afin d'obtenir une version autonome d'Agilitest : cette version spécifique n'inclut pas de mise à jour automatique au démarrage.

Accès aux applications :

L'ordinateur sur lequel Agilitest est installé doit avoir accès aux applications :

Web & webservices : accès à l'application Web par le biais d'un navigateur Web installé sur l'ordinateur.

Desktop : l'application doit être installée sur la même machine qu'Agilitest.

Application mobile : vous devez installer ATSMobileStation sur l'ordinateur sur lequel sont installés les mobiles physiques ou émulés.

SAP Gui : La machine doit disposer d'un accès SAPLogon

Agilitestet et ATS, grâce au logiciel gratuit ATSMobilestation, téléchargeable ici, vous permettent d'utiliser les émulateurs Android de Genymotion Desktop.

Téléchargez et installez la solution Genymotion

La condition préalable pour pouvoir le faire est d'avoir téléchargé et installé la solution Genymotion et d'avoir installé un émulateur.

Par défaut, la solution Genymotion Desktop vous permet de lancer des émulateurs pour votre usage personnel. Cela peut vous permettre d'effectuer des tests avant d'opter pour une version payante.

L'avantage d'utiliser cette solution est qu'elle est parfaitement intégrée à Agilitest et ATS, et que vous pourrez très facilement lancer une grande variété d'émulateurs Android :

• Différents formats (téléphone, petite tablette, grande tablette)
• Version Android
• Densité de l'écran
• Taille de l'écran en pixels
• Source :

‍

Il vous suffit ensuite de lancer un émulateur :

Ensuite, vous devez lancer l'ATSMobilestation, qui indique les terminaux qui sont connectés, vous avez plusieurs possibilités :

• Terminaux physiques connectés au PC / serveur
• Emulateurs installés sur le PC / serveur
• Les émulateurs Genymotion dans le cloud
• Emulateurs de bureau Genymotion

Dans notre cas, l'émulateur Genymotion Desktop apparaît directement dans la liste des terminaux connectés au PC :

Il suffit de l'utiliser pour effectuer un test mobile.

Dans l'image ci-dessous, vous pourrez identifier : la solution Genymotion Desktop ayant lancé un émulateur Android, Agilitest et ATSMobilestation lancés et effectuant une opération de capture sur une touche de la calculatrice.

Agilitestet et ATS, grâce au logiciel gratuit ATSMobilestation, téléchargeable ici, vous permettent d'utiliser des émulateurs Android dans le cloud Genymotion.

La condition préalable est de disposer d'un compte cloud Genymotion.

Au lancement, l'ATSMobilestation montre les appareils connectés :

• Terminaux physiques connectés au PC / serveur
• Emulateurs installés sur le PC / serveur
• Emulateurs Genymotion dans le nuage

Dans notre cas, nous avons un mobile physique OnePlus connecté par USB et contrôlé par le réseau Wifi.

Configuration de votre compte Genymotion

ATSMobilestation gérera votre compte Genymotion, lancera des émulateurs et effectuera des tests sur ceux-ci en utilisant le langage de script Python gmsaas.

Cliquez sur l'icône "engrenage" pour ouvrir le menu des paramètres :

Vous devez installer Python, puis saisir son chemin dans le champ "Dossier Python".

Cliquez sur "Installer les composants", ATSMobilestation va installer les composants gmsaas :

Entrez vos informations d'identification Genymotion :

L'installation est terminée !

Cliquez sur "Terminer".

Lancer un émulateur Genymotion dans le cloud

L'ATSMobilestation affiche alors un nouvel onglet, avec la liste des terminaux Genymotion auxquels vous pouvez avoir accès :

Cliquez sur le + vert pour lancer un émulateur dans le cloud, l'émulateur s'installe alors...

... et s'affiche dans la liste des émulateurs disponibles. L'icône "chaîne" indique que l'émulateur est lié à votre instance d'ATSMobilestation. Les émulateurs disponibles sur le même compte Genymotion mais sur d'autres PCs/Serveurs n'ont pas de chaîne.

Vous pouvez également les compter dans l'onglet "Genymotion cloud" :

Le nouveau terminal est disponible dans la liste des terminaux connectés :

Utiliser le Genymotion

Vous pouvez l'utiliser dans Agilitest pour écrire ou lancer des tests :

Tout d'abord, vous devez être familiarisé avec l'utilisation de l'ATSMobilestation, qui centralise tous les terminaux mobiles accessibles depuis un PC/serveur donné.

ATSMobilestation peut se connecter à vos terminaux physiques, avec des terminaux mobiles dans le cloud (via la solution Genymotion, qui est également disponible sur le bureau), mais aussi réaliser des tests sur des terminaux Android émulés installés sur votre machine.

Il en existe plusieurs, et nous ne disposons pas d'une liste exhaustive des terminaux supportés par ATSMobilestation, en général, un accès à adb est suffisant pour que nous les supportions.

Pour la démonstration, nous allons utiliser un émulateur fourni par Google avec la suite Android Studio

Installer Android Studio et lancer un émulateur

En cliquant sur le lien précédent, vous pourrez télécharger et installer Android Studio. Il n'y a pas de difficulté particulière, assurez-vous simplement que l'installation de "Android Virtual Device" est prise en compte.

A la fin de l'installation, lancez Android Studio et sélectionnez le menu "Tools" et "AVD Manager" :

Cliquez sur "Créer un dispositif virtuel".

Sélectionnez ensuite un type d'appareil, la version d'Android sur laquelle vous voulez qu'il fonctionne et téléchargez l'image système.

Terminez ensuite le téléchargement et la configuration de votre appareil, vous devriez alors le voir apparaître dans votre liste de terminaux disponibles :

Ensuite, il suffit de cliquer sur le bouton "Play" à droite, et d'attendre que le système se lance.

Lancer ATSMobileStation

Lancez ensuite ATSMobilestation qui repérera automatiquement les émulateurs Android lancés, et vous devriez voir votre émulateur apparaître dans la liste :

Le bouton de droite vous permet de lancer l'émulateur, de l'arrêter, etc.

Une fois lancé, il apparaît dans la liste des "Périphériques connectés", dans l'image ci-dessous vous verrez un émulateur lancé sur votre PC, et un téléphone connecté à votre PC : les deux sont accessibles par ATS et Agilitest.

Lancer Agilitest

Ensuite, il vous suffit de lancer Agilitest et vous devriez voir apparaître votre émulateur dans la liste des terminaux accessibles pour effectuer un test :

Il vous suffit ensuite de sélectionner une application à tester.

Agilitest vous permet d'automatiser la création de fichiers d'archives HTTP (HAR) qui seront utiles pour analyser les flux réseau pendant l'exécution d'un test.

Format HAR

Le format HAR permet d'enregistrer le détail des Urls visitées et la chronologie de leur chargement lors d'une requête HTTP.

Il enregistre les informations relatives à l'ensemble des pages, fichiers et images qui sont téléchargés par un navigateur lorsque vous visitez une URL.

Vous pouvez ensuite utiliser un logiciel de visualisation du fichier .HAR qui vous permettra d'afficher cette requête sous forme de graphique.

Vous pouvez obtenir ce résultat :

Plus d'informations sur le format HAR : https://en.wikipedia.org/wiki/HAR_(file_format)

Comment cela fonctionne dans Agilitest

Le format HAR enregistré par Agilitest implique plus que la visite d'une seule URL, il peut enregistrer toutes les performances d'un test logiciel et toutes les URL qui ont été visitées par le test, et il peut le faire action par action.

Nous avons donc développé de nouvelles actions ATS spécifiques à cette intégration, vous pouvez mettre des filtres URL, démarrer et arrêter l'enregistrement également.

Voici le détail des opérations à effectuer :

Activation du mode performance

Le mode performance n'est pas activé par défaut dans Agilitest.

To do this you will need to modify your .atsProperties file and insert an XML element <performance> inside <execute>:

<?xml version="1.0" encoding="utf-8">
<execute>
  ...
<performance>
<idle>4</idle>
<blacklist>
<url>https:\/\/www.google.com.*</url>
<url>https:\/\/accounts.google.com.*</url>
</blacklist>
</performance>
  ...
</execute>
...

Il faut savoir que la balise de performance permet d'intégrer d'autres éléments de configuration.

Par exemple, l'intégration avec Octoperf vous permettra de transmettre vos fichiers HAR directement dans des projets Octoperf pour effectuer des tests de charge.

Les correspondances des paramètres sont les suivantes :

• idle: Permet de modifier le délai d'attente réseau par défaut. Voir l'action "Configurer la capture réseau" ci-dessous.
• liste noire: Permet de spécifier les URL dont vous ne voulez pas que les informations de navigation soient exportées dans le fichier HAR. Cela vous permet de supprimer les publicités, par exemple.

Une fois cette configuration effectuée, si vous redémarrez Agilitest,vous verrez apparaître un menu Performance sur le côté droit de votre écran :

‍

Le menu Performance est déroulant et affiche les sous-menus suivants :

‍

Ouvrir un canal en mode d'enregistrement HAR

Vous devez créer ou modifier votre action d'ouverture canal pour indiquer à Agilitest que vous souhaitez activer les fonctions d'enregistrement et de contrôle du réseau.

Cliquez sur la troisième icône en bas à droite.

L'action d'ouverture de canal montre une icône identique au menu "Performances".

Ajouter des fonctions d'enregistrement

Voici le détail des différentes fonctions disponibles :

Paramètres

Configurer la capture réseau.

Vous pouvez modifier le comportement d'Agilitest lors de l'enregistrement du replay du test en permettant de fournir un .HAR :

• Latence : Permet d'ajouter la latence en secondes à toutes les requêtes envoyées et reçues par le navigateur web utilisé par Agilitest.
• Trafic inactif: Durée maximale en secondes avant de considérer que le trafic réseau est terminé après la dernière activité réseau enregistrée (par défaut : 3 secondes).
• Upload : Limite la bande passante de la liaison montante en octets / seconde.
• Télécharger : Limite la bande passante de la liaison descendante en octets / seconde.

L'ajout d'un filtre d'URL vous permet de filtrer les URL qui seront comptabilisées et enregistrées dans le fichier HAR correspondant. Vous pouvez ajouter autant de filtres que vous le souhaitez.

Dossier

Cette action est un interrupteur marche/arrêt qui indique à Agilitest quand vous voulez commencer à enregistrer le trafic réseau.

Vous pouvez arrêter et reprendre l'enregistrement à volonté en fonction des actions qui sont effectuées par Agilitest.

Récupérer le fichier HAR

Lorsque votre test est effectué, si le site canal a été ouvert en mode Performance, l'action de fermeture de canal génère le fichier .HAR.

Il vous suffit de le récupérer dans le répertoire suivant :

cible/performance/générerHAR.

Qu'est-ce que Octoperf?

Octoperf est une solution de test de charge SaaS et On-Premise .

Agilitest vous permet d'automatiser la génération de scénarios et de les importer directement dans votre compte Octoperf.

Les deux solutions sont donc très complémentaires puisque vous pourrez transformer tout test fonctionnel réalisé avec Agilitest en un test de charge dans Octoperf.

Principe

Le principe est le suivant :

• Vous enregistrez un scénario de test fonctionnel avec Agilitest.
• Vous décidez que ce scénario est un bon candidat pour les tests de chargement effectués avec Octoperf : vous ajoutez les actions ATS nécessaires à son instrumentation.
• Ensuite vous rejouez ce scénario, Agilitest génère un fichier .HAR et peut le transmettre directement à votre compte Octoperf, dans l'espace de travail et le projet que vous souhaitez.
• Vous pouvez ensuite utiliser dans Octoperf les données qui ont été importées par Agilitest pour effectuer des tests de charge et analyser les résultats.

Cela permet de bénéficier de la capacité d' Agilitest d' enregistrer et de rejouer un scénario pour transformer n'importe quel scénario fonctionnel en test de charge.

Nous avons donc développé de nouvelles actions ATS spécifiques à cette intégration d'Octoperf.

Voici le détail des opérations à effectuer :

Activation du mode Octoperf

Tout d'abord, vous devez activer le mode Performance, vous permettez la génération de fichiers HAR

It is also necessary to activate the Octoperf mode, and the two operations can be carried out at the same time, because you will have to modify your .atsProperties configuration file and insert a <performance> tag inside the <execute> tag.

Le code suivant active les deux modes nécessaires :

<?xml version="1.0" encoding="utf-8"?>
<execute>
  ...
<performance>
<octoperf>
<host>https://api.octoperf.com</host>
<apiKey>1b3b3b85-bbb5-219b-936b-61bb521b23ed</apiKey>
<workspaceName>AgilitestWorkspace</workspaceName>
<projectName>AgilitestCaptureProject</projectName>
</octoperf>
<idle>4</idle>
<blacklist>
<url>https:\/\/www.google.com.*</url>
<url>https:\/\/accounts.google.com.*</url>
</blacklist>
</performance>
  ...
</execute>
...

Les paramètres sont les suivants :

• host: correspond à l'adresse du serveur Octoperf, en général laissez-la par défaut.
• apiKey: correspond à votre clé API que vous pouvez obtenir sur votre compte Octoperf en cliquant sur la section "Profil" de votre compte

Il est alors affiché non visible en bas à droite, il suffit de le rendre visible et de le copier en cliquant sur l'icône "œil".

• workspaceName : Correspond au nom de l'espace de travail Octoperf dans lequel se trouve votre projet
• projectName: Le nom de votre projet Octoperf

Une fois cette configuration effectuée, si vous redémarrez Agilitest, vous verrez apparaître un menu Performance sur la droite de votre écran :

Le menu Performance est déroulant et affiche les sous-menus suivants :

Ouvrir un canal en mode d'enregistrement Octoperf

Vous devez créer ou modifier votre action d'ouverture canal pour indiquer à Agilitest que vous souhaitez activer les fonctions d'enregistrement et de contrôle du réseau.

Cliquez sur la troisième icône en bas à droite.

L'action d'ouverture de canal fait apparaître une icône identique au menu "Performances".

Ajouter des fonctions d'intégration avec Octoperf

Voici le détail des différentes fonctions disponibles :

Paramètres

Vous permettra de configurer la capture du réseau.

Vous pouvez modifier le comportement d'Agilitest lors de l'enregistrement de la relecture du test pour fournir un .HAR :

• Latence : Permet d'ajouter la latence en secondes à toutes les requêtes envoyées et reçues par le navigateur web utilisé par Agilitest.
• Traffic idle : Maximum time in seconds before considering network traffic to have ended after the last recorded network activity (default: 3 seconds). The default value of this parameter can be modified with the <idle> tag in your .atsProperties file.
• Upload : Limite la bande passante de la liaison montante en octets / seconde.
• Télécharger : Limite la bande passante de la liaison descendante en octets / seconde.

L'ajout d'un filtre d'URL vous permet de filtrer les URL qui seront comptabilisées et enregistrées dans le fichier HAR correspondant. Vous pouvez ajouter autant de filtres que vous le souhaitez.

Vous avez la possibilité d'ajouter des filtres d'URL non autorisés, qui ne seront donc pas enregistrés dans votre fichier HAR. Comme il s'agit plutôt d'un sujet de configuration générale, cela se fait directement dans la configuration de votre fichier .atsProperties.

Dossier

Cette action en mode "switch on / off" vous permet d'indiquer à Agilitest quand vous voulez commencer à enregistrer le trafic réseau.

Vous pouvez arrêter et reprendre l'enregistrement à volonté en fonction des actions qui sont effectuées par Agilitest.

Sauver l'UEV

Cette action complète l'enregistrement, finalise la génération du fichier .HAR et l'envoie directement à votre compte Octoperf selon les méthodes définies dans les paramètres de configuration de votre fichier .atsProperties.

Vous avez la possibilité d'agir sur les informations suivantes :

• Modifier la description de l'UEV qui sera envoyée à Octoperf

• Changer le nom de l'utilisateur virtuel
• Ajouter une liste de tags, séparés par des virgules, qui seront utilisés dans Octoperf.
• Sélectionner la possibilité d'annexer les actions.
• Append : les actions HAR s'accumulent dans votre projet Octoperf
• Don't append : les HAR précédemment enregistrés dans votre projet sont effacés avant l'envoi du fichier HAR.

Il y a un certain nombre de conseils à connaître lors de l'automatisation des tests logiciels en général, et avec Agilitest en particulier pour rendre vos tests plus robustes.

En effet, en matière de tests logiciels automatisés, il y a un outil d'automatisation, et il y a aussi le SUT (système sous test) qui a son propre comportement, ses temps de réponse et ses particularités dont il faudra tenir compte.

Ce billet présente une série d'astuces que nous vous recommandons d'utiliser pour rendre vos tests plus robustes.

A propos de l'utilisation de Max / Wait for dans un test

Votre serveur est lent à répondre : tant pis, nous allons attendre 5 secondes de plus !

Nous ne vous recommandons pas de le faire, cette documentation vous expliquera pourquoi et comment traiter le sujet. La technique proposée vous permettra de gérer toutes les solutions où une certaine latence entre le logiciel et Agilitest peut se produire : attente d'une réponse du serveur, calcul complexe sur une solution Desktop...

Identificateurs d'objets

Certains cadres de composants génèrent des identifiants qui peuvent n'être valables que pour une session de navigateur donnée. Il est risqué de se fier à ces identifiants pour effectuer des tests, car il est fort probable que, pendant l'exécution, les identifiants aient été modifiés.

Dans certains cas, cela peut encore être fait en utilisant des expressions régulières.

Il suffit de reconnaître la partie de la valeur de l'attribut du composant à reconnaître qui est toujours fixe, par exemple un préfixe ou un suffixe, dans le cas suivant :

"select_

"id = select_4657

Pour traiter ce cas, l'expression régulière suivante appliquée à l'attribut "id" devrait faire l'affaire :

select_( d{4})

Le nombre de quatre chiffres peut donc varier en fonction des exécutions, mais nous trouverons toujours de manière très robuste le composant dont l'id commence par "select_".

La conception de ATS

Lors de la conception d'Agilitest et du langage ATS , nous avons bénéficié de plusieurs années d'expérience dans les solutions d'automatisation des marchés, et nous cherchons à pallier un certain nombre de lacunes et/ou de défauts. Cela implique la mise en place de configurations spécifiques aux environnements d'exécution : par défaut, ATS est conçu pour fonctionner correctement dans la plupart des cas, mais il est toujours possible de modifier sa configuration.

Double contrôle des propriétés

Lors de la récupération d'une valeur sur un composteur, Agilitest effectuera un double contrôle de la valeur pour s'assurer qu'il récupère une information précise et stable. Cela permet de s'assurer que les valeurs que nous voulons contrôler sont définitives et celles fournies par le test, tout en ajoutant stabilité et fiabilité.

La configuration par l'exécution du robot

La fiabilité d'un test dépend également de sa vitesse ou de sa lenteur d'exécution. En effet, les réseaux et les performances des machines peuvent mettre les tests en échec.ATS prend en compte la possibilité que les performances des machines impactent l'exécution des tests. Ainsi, lors de son lancement, ATS récupère un fichier de configuration .atsProperties spécifique au job sur lequel il s'exécute.

Cela permet d'adapter finement les environnements d'exécution au contexte souhaité, par exemple une version de logiciel de développement ou une version de production peuvent ne pas répondre de la même manière : Avec ce système, il y a beaucoup plus de garanties d'avoir toujours un replay régulier.

Configuration par navigateur

Le comportement du test et donc le résultat de son exécution peuvent également varier en fonction des navigateurs. Il est donc également possible de configurer l'environnement d'exécution en fonction des navigateurs utilisés.

La robustesse au centre des enjeux de notre produit de développement

La robustesse et la maintenabilité des tests sont au centre de nos préoccupations car nous voulons que les testeurs se concentrent sur ce qui est vraiment important pour eux. Dans le jargon Agile/Lean, nous cherchons à supprimer le "muda" (perte de temps/gaspillage) dès que nous en avons l'occasion.

Comment automatiser la validation d'une boîte de dialogue

Il arrive fréquemment que l'on doive valider une boîte de dialogue sur des supports WEB afin de confirmer ou d'annuler une action.

Pour automatiser la validation avec Agilitest, veuillez suivre les étapes suivantes :

• Ajouter une action "clic de souris".

• Cliquez sur le bouton "Racine de l'application" pour sélectionner le type d'interface parmi les suivants

Un nouveau menu apparaît :

1. Élément d'interface
2. Bouton système
3. Boîte de dialogue
4. Interface du système

• Cliquez sur le bouton "Dialog""

• Passez la souris sur l'élément pour sélectionner la réponse souhaitée, puis cliquez dessus.

• Sélectionnez le type de validation souhaité dans la boîte de dialogue :    
• Acceptez    
• Rejetez

L'action de validation de votre dialogue est automatisée.

Agilitest permet l'enregistrement de variables qui sont ensuite cryptées dans des fichiers ATS .

Comment gérer les mots de passe cryptés

Cela permet de ne pas les faire apparaître en texte brut dans les fichiers, ni dans l'interface d'édition des tests.

Vous pouvez accéder à l'utilisation d'un mot de passe crypté grâce au raccourci situé dans les touches spéciales lors de la saisie de texte.

Ils peuvent également être gérés dans le menu "Editer les propriétés du projet".

Cliquez sur "Ajouter" et entrez un double de la variable, la valeur.

Par la suite, la valeur peut être récupérée dans ATS comme une variable normale en utilisant le mot clé $pass(variable).

Ce qui diffère de la gestion normale des variables :

• Les mots de passe ne sont pas imprimés dans l'interface utilisateur de l'éditeur ailleurs que dans son menu d'édition.
• Ils ne sont pas visibles dans les fichiers ATS , pas même leurs déclarations.
• Ils n'apparaissent pas dans les fichiers ATSV.
• Ils n'apparaissent pas dans les logs et journaux générés par Agilitest et ATS.
• Chaque variable déclarée à l'aide des variables $pass() est traitée de la même manière.

Quand utiliser des mots de passe cryptés

Nous vous recommandons d'utiliser des mots de passe cryptés lorsque vous ne pouvez pas faire autrement.

Par exemple, nous ne vous recommandons pas d'effectuer vos tests avec des comptes utilisateurs réels qui sont dans vos équipes en cryptant les mots de passe. La solution que nous vous recommandons est de créer des utilisateurs dédiés aux tests et disposant de leurs propres privilèges, si possible limités.

Si vous ne pouvez pas faire autrement, par exemple si vous devez tester le compte administrateur, nous vous conseillons de le faire sur des environnements similaires à la production mais sécurisés différemment (par exemple physiquement dans vos locaux).

Enfin, si vous effectuez des tests sur des systèmes qui se trouvent dans le nuage, vous ne pourrez pas faire autrement, et dans ce cas, nous vous conseillons de compléter ce mécanisme, par exemple en passant par des protocoles de transfert sécurisés comme https ou en utilisant des mots de passe à usage unique émis par un serveur sécurisé.

Vous venez d'obtenir votre licence ou une version d'essai et à l'aide de cette documentation, vos premiers pas sur Agilitest seront guidés. Voici un article pour vous aider à installer Agilitest et ensuite commencer à réaliser vos premiers tests.

▶️ Vous pouvez trouver un tutoriel sur l'installation d'Agilitest sur notre chaîne Youtube.

‍

‍

1. Télécharger Agilitest

Agilitest s'installe sur un ordinateur fonctionnant sous le système d'exploitation Windows. Avant de commencer votre installation, il est préférable de prendre connaissance des prérequis techniques listés dans une documentation dédiée.

Si vous n'avez pas accès aux archives d'Agilitest, allez à la page : https://www.agilitest.com/free-trial.

Entrez vos informations personnelles et nous reviendrons vers vous pour une courte démonstration avant l'installation.

Notre équipe d'assistance vous donnera un lien pour télécharger l'archive.

‍

Une fois que vous avez un lien pour télécharger Agilitest, et que vous êtes sur d'avoir une licence active ou une version démo, vous pouvez installer Agilitest sur votre ordinateur.

Pour ce faire, ouvrez votre répertoire de téléchargement dans votre explorateur Windows pour récupérer votre dossier .zip.

Le dossier .zip contient tous les fichiers nécessaires pour faire fonctionner Agilitest.

Vous pouvez extraire ce dossier en cliquant sur la commande "Extraire tout".

Ensuite, placez votre dossier dans le répertoire de votre choix dans lequel vous pouvez créer un sous-dossier nommé "Agilitest" afin de mieux organiser vos fichiers.

‍

🔸 Avertissement

Assurez-vous que vous placez votre dossier Agilitest dans un répertoire où vous avez des droits d'accès. Si ce n'est pas le cas, cela peut poser des problèmes lors de la création de scripts. Le répertoire "Document" est recommandé.

‍

Cliquez sur "Ok" pour confirmer l'emplacement de votre archive et des fichiers qui la composent.

Ouvrez votre dossier Agilitest puis double-cliquez sur votre fichier .exe pour lancer Agilitest.

‍

‍

2. Lancer Agilitest

La fenêtre ChangeLog apparaît à l'ouverture d'Agilitest lorsque c'est la première fois que vous ouvrez Agilitest ou lorsque des modifications ont été apportées depuis la dernière fois que vous avez ouvert le logiciel.

Le ChangeLog est là pour vous informer de la dernière version courante d'Agilitest et des modifications qui ont été apportées au logiciel (parfois avec une courte vidéo explicative pour mieux comprendre).

Pour votre première ouverture d'Agilitest, les conditions d'utilisation vous seront présentées.

Lisez-les et cliquez sur le bouton "Accepter".

‍

Une fois cette opération effectuée, les premières mises à jour des composants de ATS démarreront automatiquement.

Une mise à jour est faite environ toutes les semaines, notamment pour supporter les évolutions des navigateurs et des webdrivers.

Agilitest fonctionne avec le JDK (Java Development Kit). Java sera utilisé pendant toute la phase de compilation et d'exécution des projets automatisés. Par défaut, vous aurez besoin d'un JDK dans votre environnement.

‍

Pour paramétrer votre JDK, vous pouvez le faire à partir du menu des paramètres dans Agilitest.

Il est possible d'établir un lien avec un JDK existant sur votre ordinateur ou vous pouvez le télécharger directement depuis Agilitest comme indiqué en cliquant sur le bouton "Télécharger". Ceci téléchargera le JDK ouvert qui est une version auto-portée du JDK.

Les deux prérequis pour utiliser ATS sont le package ATS et le JDK qui rendent l'éditeur fonctionnel.

Vous avez besoin d'au moins une version 11 du JDK. Agilitest téléchargera la dernière version.

‍

💡 Conseil

Si vous avez installé UFT avec un JDK dans les variables d'environnement, alors vous pouvez faire cohabiter Agilitest avec cet open JDK existant.

Vous pouvez revenir à l'interface de l'éditeur en fermant la fenêtre ouverte.

‍

La licence est située tout en haut de votre éditeur. En cliquant dessus, une fenêtre de licence apparaîtra avec un certain nombre d'informations telles que l'ID, l'ID système, etc.

Vous pouvez également créer ou modifier votre identifiant en saisissant un autre identifiant dans la barre de saisie, puis en cliquant sur les boutons "Créer un compte" ou "Modifier l'identifiant".

‍

Vous pouvez également trouver des informations sur votre licence dans la section "Aide".

‍

Dans le menu"Aide", vous trouverez également divers liens qui complètent l'utilisation d'Agilitest.

Vous y trouverez le lien pour télécharger Agilitest. Des liens pour télécharger Mobile Station sur Windows ou MacOs et un lien pour télécharger le lecteur ATSV.

Dans la barre latérale de droite se trouvent diverses ressources avec des liens vers la documentation d'Agilitest, le site web, des tutoriels, des webdrivers et une liste d'intégrations que vous pouvez utiliser avec Agilitest.

‍

Dans le menu Outils, vous trouverez des outils supplémentaires qui peuvent améliorer l'utilisation d'Agilitest.

‍

Par défaut, Agilitest affichera une icône d'erreur s'ils ne sont pas téléchargés. Il est recommandé de tous les télécharger lors de l'installation pour les avoir accessibles.

‍

L'éditeur peut être divisé en plusieurs parties. La partie gestion de projet avec des boutons pour créer un projet ou des composants.

‍

La section des réglages et configurations avec la catégorie Aide, Outils, etc...

‍

L'explorateur de projet où sont placés les différents projets et leurs composants.

‍

La partie gestion de canal qui est utilisée pour gérer l'exécution des scripts.

‍

Puis la partie consacrée aux variables en dessous.

‍

Une documentation est à votre disposition pour plus de détails concernant l'interface Agilitest.

‍

3. Créer un nouveau projet

▶️ Vous pouvez trouver un tutoriel sur la façon de créer un nouveau projet sur notre chaîne Youtube.

Pour créer un nouveau projet, cliquez sur l'action "Nouveau projet".

‍

Vous pouvez renommer votre projet et changer son domaine si vous voulez diviser votre projet en différents domaines.

‍

Lorsque vous créez un nouveau projet, il créera un répertoire de projet "AgilitestProjects" où tous vos projets seront automatiquement placés.

Le chemin d'accès à votre projet dans l'explorateur Windows sera indiqué. Vous pouvez également ajouter une description à votre projet.

‍

Une fois le projet créé, il sera placé dans l'arborescence du projet dans l'explorateur de projet.

Pour trouver votre projet, vous devez passer par le répertoire "src"(source) > "main" > "ats" .

‍

Note: Les scripts Agilitest sont des fichiers ActionTestScript (.ats). Vous pouvez créer des sous-répertoires pour mieux catégoriser vos projets. Vous pouvez également créer des sous-scripts, qui n' ont aucune différence avec les scripts, les deux sont des fichiers ats , seul l'un est appelé par l'autre.

‍

Il y a deux façons de créer un script :

1. En faisant un clic droit sur le fichier "ats"et en sélectionnant "Créer un script ATS ".

          2. En cliquant sur le bouton "Nouveau composant".

           Et en sélectionnant "Créer un script ATS "

‍

Entrez le nom de votre script. Cela ouvrira une fenêtre correspondant aux interprétations graphiques des actions qui seront effectuées sur votre script. Le format ATS est un format textuel qui décrira toutes ses actions.

‍

Pour faire le lien entre Agilitest et l'application testée, vous devez ouvrir un canal.

Pour ce faire, cliquez sur le menu "Canaux" et sélectionnez l'action "Démarrer un canal".

Il est possible de faire du multicanal en créant plusieurs actions de démarrage de canaux. Le nom de ces canaux s'adaptera automatiquement au nombre de canaux ouverts. Il est possible de les renommer.

‍

🔸 Avertissement

Il est possible de ne faire qu'une seule instance avec les navigateurs web, ce qui signifie que pour un même navigateur ouvert dans plusieurs canaux, cela correspondra à plusieurs onglets ou alors des canaux qui ouvrent différents navigateurs en parallèle.

‍

Une fois que vous avez créé l'action canal , cliquez sur le bouton d'exécution pour lancer l'action

‍

La fenêtre d'ouverture de canal s'ouvre alors avec diverses informations sur le navigateur et le système d'exploitation.

‍

Sur l'interface Agilitest, l'ouverture du canal sera signalée par sa présence dans la zone de gestion des canaux avec une ligne qui apparaît avec le nom donné au canal.

Dans un test web, pour accéder à une URL, il faut cliquer sur le bouton "Navigation"et sélectionner "URL du navigateur".

Cliquez sur l'action pour ouvrir la barre de saisie et indiquer l'url que vous souhaitez lancer.

Une fois le site ouvert, vous pouvez effectuer diverses actions en utilisant les éléments qui le composent. Pour ce faire, vous devez capturer les éléments avec l'outil de capture.

Cliquez sur le bouton "Capturer"dans la gestion des canaux

L'outil de capture s'ouvre en plaçant un filtre sur le canal et en faisant apparaître la fenêtre de capture. Avec votre souris, vous pouvez survoler les éléments DOM qui seront mis en évidence par un rectangle bleu.

Pour capturer un élément, appuyez sur la touche CTRL de votre clavier pour ouvrir la fenêtre parent de l'élément capturé.

Cette fenêtre affiche l'arborescence de l'élément depuis la racine jusqu'au composant ciblé. Chaque branche de l'arbre possède des propriétés qui peuvent être sélectionnées comme attributs. Les propriétés peuvent être prises dans les différentes branches de l'arbre pour plus de précision.

‍

🔸 Avertissement

Faites attention aux propriétés qui vont changer et qui ne pourront pas être reconnues dans le script par la suite (Exemple: texte, classe, etc).

‍

Cliquez sur un attribut pour ouvrir la valeur de la propriété. Celle-ci peut être modifiée sous la forme d'une expression régulière.

Une fois les attributs sélectionnés, cliquez sur le bouton des statistiques pour confirmer l'unicité de l'élément trouvé.

Si plusieurs éléments correspondent à ces attributs, vous pouvez en sélectionner d'autres en remontant dans les branches.

Une fois que c'est fait, vous pouvez glisser et déposer votre élément dans le script, ce qui créera une action.

Sélectionnez l'action que vous voulez utiliser.

‍

Une fois la capture terminée, vous pouvez la fermer à partir du menu de gestion canal dans Agilitest.

Ou vous pouvez cliquer sur le bouton "Fermer" de la fenêtre de capture pour arrêter l'outil de capture.

‍

Vos actions seront ajoutées à votre script. Il est possible de les déplacer manuellement.

1. Chaque action possède un index qui est automatiquement ajouté et s'adapte à sa position dans le script.
2. Dans l'action se trouve la nature de l'action qui peut être configurée.

Exemple : Pour la saisie du texte, vous pouvez entrer le texte que vous souhaitez voir apparaître dans votre test.

       3. Enfin, vous verrez le composant qui a été capturé. Vous pouvez cliquer dessus pour avoir accès à sa valeur que vous pouvez modifier. Vous pouvez ajouter des parents et des enfants à votre élément et modifier la nature du composant.

‍

Une fois que votre script est terminé, vous pouvez lancer l'exécution en cliquant sur le bouton "Lecture" dans le menu de gestion des canaux.

‍

🔸 Avertissement

En remote access, assurez-vous que vos sessions restent ouvertes pendant les exécutions.

‍

Lorsque vous voulez fermer votre canal, vous pouvez créer une action "Fermer canal".

‍

Vous pouvez également fermer le canal actuel à partir du menu de gestion des canaux.

Pour ce faire, cliquez sur le bouton "Fermer".

Ou vous pouvez cliquer sur le bouton "Arrêter" dans la ligne du canal

‍

🔸 Avertissement

Vous ne devez pas fermer manuellement votre canal directement depuis l'application. Agilitest n'est pas intrusif (pas de plugin), il n'a aucun moyen de savoir que vous avez fermé une application directement par les actions du système d'exploitation (Exemple: en cliquant sur la croix de la fenêtre de l'application).

‍

‍

Agilitest vous permet d'appeler des sous-scripts conditionnels, c'est-à-dire que l'évaluation d'une condition entraîne l'appel ou non du sous-script.

Comment appeler des sous-scripts conditionnels

Pour effectuer cette opération, vous devez créer au préalable une action d'appel de sous-script.

Ensuite, cliquez sur "appel de script" puis "créer une condition".

Agilitest affiche alors une popup de sélection d'une variable sur laquelle la condition est basée, qui doit être une égalité.

Une seule condition peut être sélectionnée, et il est possible de supprimer une condition définie en recliquant sur "Appel de script".

Les autres paramètres d'appel du sous-script restent les mêmes : vous pouvez passer des variables d'entrée ou un fichier CSV.

Pendant l'exécution, Agilitest évaluera la condition et, en fonction du résultat, il appellera ou non le sous-script en utilisant les paramètres définis.

Pour l'instant, seule l'égalité a été proposée comme condition, et Agilitest vous montrera dans l'éditeur le résultat de l'état actuel de l'appel des sous-scripts :

• Flèche verte : le sous-scriptum serait appelé
• Sense-forbidden : le sous-script ne serait pas appelé

Nous vous conseillons d'utiliser cette fonction avec beaucoup de précautions, car elle vous permettra d'intégrer la non-généricité dans vos tests, et donc potentiellement des dysfonctionnements liés à des données non contrôlées.

Les cas pour lesquels nous le recommandons sont les suivants :

• Effectuer un appel en fonction de la valeur d'une variable globale, cela vous permet d'effectuer des opérations de mise en place en fonction de la présence ou non d'une variable dans les paramètres d'appel de l'intégration continue par exemple.
• Dans un sous-script avec un fichier CSV : appel d'un script en fonction d'un paramètre du fichier CSV passé en appel de sous-script, cela nécessite d'avoir un deuxième niveau de sous-script, mais permet de gérer des contrôles dédiés.

Dans certains cas particuliers, il est obligatoire d'effectuer une opération à un endroit très précis du logiciel testé, et où l'utilisation d'un standard locator basé uniquement sur les attributs ne peut être utilisée.

Cela se produit par exemple lorsque le dernier élément dont la structure est visible représente une grande partie de l'écran, par exemple une grande image, et que la zone cliquable est précise : il peut s'agir d'une carte d'image web, d'un composant interne d'une application de bureau, etc.

La solution apportée par Agilitest est de permettre la définition précise du point sur lequel les actions seront effectuées, en spécifiant ses coordonnées cartésiennes par rapport à la fenêtre d'un composant.

Dans l'exemple ci-dessous, nous voulons cliquer sur la Californie, mais le dernier élément visible dans la structure HTML est l'image complète des États-Unis.

La définition d'une coordonnée cartésienne locator se déroule en deux phases :

Sélectionnez le composant de référence

Vous commencez par sélectionner un type standard locator, soit par ses attributs, soit par reconnaissance graphique.

En sélectionnant le locator, vous verrez un bouton "emplacement cible" en bas de la fenêtre de sélection : cliquez dessus.

Vous pouvez ensuite cibler précisément le point où l'action doit avoir lieu en cliquant dessus.

Agilitest vous informe qu'il a généré un locator avec un ciblage cartésien en ajoutant une cible dans la zone de départ du drag-drop.

Si vous déposez ce locator dans l'éditeur, Agilitest génère une action avec des coordonnées cartésiennes.

Grâce à cette fonctionnalité, il est possible de générer un locator en dehors du composant sélectionné.

Afin de ne pas être intrusif avec le logiciel testé, Agilitest ne déploiera pas de plugin sur les navigateurs et apparaîtra en surimpression des fenêtres de l'application testée. Dans certains cas, cela peut provoquer des décalages d'affichage entre les deux applications, notamment lors de l'affichage des boîtes de sélection des composants.

Comment faire face à un élément débordant

Symptôme : Le mode capture de mon éditeur AGILITEST n'est pas parfaitement aligné sur la page sur laquelle je veux enregistrer les opérations.

Vérifiez que votre système Windows n'a pas modifié automatiquement la taille des textes, applications et autres éléments affichés sur chacun de vos écrans. De par son nom, ce paramètre doit être réglé à 100% pour le bon fonctionnement de la capture AGILITEST. Pour ouvrir le menu d'affichage : Faites un clic droit dans le fond de la fenêtre et sélectionnez "Paramètres d'affichage".

‍

‍

AGILITEST propose à ses utilisateurs de pratiquer le Data-Driver Testing tant pour configurer des campagnes de tests que pour adapter un script à son contexte et optimiser la couverture des tests via son jeu de données.

Cela passe par une fonction spécifique : L'éditeur Agilitest permet de passer un fichier CSV comme paramètre d'un appel de sous-script. Par la suite, lors de la relecture du test, le sous-script sera appelé autant de fois qu'il y a de lignes dans le fichier CSV, en passant comme variables d'entrée du sous-script les valeurs des colonnes de chaque ligne.

Comment utiliser un fichier CSV pour data-driven testing

Voici comment procéder :

• Sélectionnez le répertoire src/assets/data dans l'explorateur de projet.

• Faites un clic droit et sélectionnez "Créer un fichier CSV".
• Entrez le nom du fichier CSV : le fichier est créé vide dans l'arborescence src/assets/data.

• Double-cliquez sur le fichier pour l'éditer : Agilitest édite votre fichier vide
• Vous pouvez cliquer sur"Ajouter un paramètre" pour ajouter une colonne à votre fichier, et sur"Ajouter une itération" pour ajouter une ligne.

Ensuite, vous pouvez saisir des valeurs directement dans les cellules qui ont été créées.

• Créer une action de type"Appel de sous-scriptum".
• Faites glisser le fichier CSV directement de la zone "Project Explorer" vers votre nouvelle action "Call script" : Agilitest prend en compte ce nouveau fichier CSV lors de l'appel du sous-script.

Une fois ce fichier complété, vous pouvez récupérer les variables dans votre sous-script en utilisant la fonction $param() et en passant l'index de la colonne du paramètre qui vous intéresse.

Par exemple : $param(0) renvoie la valeur de la première colonne.

• Conseil 1: Vous pouvez combiner les appels à $param avec d'autres zones de texte pour générer des textes plus complexes. L'exemple ci-dessus va générer un identifiant de bouton "Btn1" à partir de la valeur "1" passée en entrée.
• Astuce 2: Vous pouvez donner une valeur par défaut dans la fonction $param comme deuxième variable, cela vous permet d'utiliser le sous-script comme un script directement utilisable. Btn $param(2,1) retournera Btn1 si le script n'a pas été appelé par un script parent.
• Conseil 3: Pour commencer à tester votre script, vous pouvez commencer par appeler votre sous-script en passant des paramètres codés en dur.

La vidéo ci-dessous résume les étapes de la création d'un fichier CSV et de son itération à l'aide d'un sous-script.

Pour aller plus loin, vous pouvez consulter notre article sur l'intérêt d'exploiter data-driven testing avec Agilitest et qui propose une vidéo de webinaire sur le sujet.

Il peut arriver dans l'automatisation des tests qu'un élément ne soit plus reconnu lors d'une exécution en raison de modifications apportées au logiciel.  

Pour y remédier, AGILITEST permet d'ajuster directement les tests dans l'éditeur.

Localisation et analyse

L'utilisateur peut utiliser la vidéo d'exécution du test raté et/ou un rapport illustré pour comprendre et localiser l'échec de la reconnaissance. Il existe alors deux possibilités :

• L'élément initialement recherché n'existe plus dans le logiciel testé.
• L'élément initialement recherché existe mais n'est plus reconnu.

Corriger le test

Si l'élément recherché n'existe plus :

• Le test peut être modifié en supprimant cette action directement par "clic droit" via l'éditeur de test.

• L'utilisateur vérifie les actions précédentes, liées et suivantes dans l'exécution du test, si nécessaire.
• Sauvegardez la modification.

Si l'élément recherché existe bien mais n'est plus reconnu :

• Une modification du test est donc nécessaire via notamment une mise à jour des critères de reconnaissance de cet élément de l'éditeur AGILITEST.
• Pour cela, AGILITEST indique précisément quel attribut n'est pas trouvé pour localiser cet élément.

• Ensuite, ouvrez le mode de capture via l'éditeur.
• Survolez à nouveau cet élément sur le logiciel à tester.
• Appuyez sur le bouton CTRL pour capturer l'élément

• Ajuste les attributs de détection (il est possible d'utiliser une "expression régulière" sur chaque attribut à des fins de robustesse).

• Valider l'unicité de la détection via le test statistique incorporé.

Glissez-déposez ces nouveaux attributs sur l'action concernée par cette "non détection" afin de la mettre à jour.

• Sauvegardez la modification.

AGILITEST peut ne pas localiser automatiquement l'emplacement d'installation des navigateurs sur lesquels vous souhaitez automatiser les tests fonctionnels.

Comment localiser l'installation du navigateur

Message d'erreur relatif :

Pour remédier à cela, il suffit de configurer manuellement le fichier de configuration ATS accessible directement depuis l'éditeur via le menu "Paramètres" > bouton "Editer la configuration".

Le fichier sera automatiquement ouvert avec votre éditeur de fichiers par défaut :

Il vous suffira de définir le chemin spécifiquement établi sur votre système pour accéder aux fichiers d'exécution des navigateurs cibles ("opera.exe" dans notre exemple).

Sauvegardez la modification du fichier de configuration.

Fermez et redémarrez AGILITEST pour prendre en compte la modification.

Le fichier de configuration est également utilisé pour configurer d'autres fonctions de l'éditeur AGILITEST. Pour plus d'informations, veuillez consulter la section installation et configuration> Guide d'utilisation - Configuration de l'éditeur

Vous venez de commander une licence Agilitest et vous devriez avoir reçu votre identifiant client. Si ce n'est pas le cas, veuillez contacter notre service commercial qui vous le fournira. (mail : contact@agilitest.com )

Comment activer votre licence Agilitest

Voici toutes les informations nécessaires pour obtenir l'activation de vos licences sur vos postes de travail, cette opération doit être faite pour chaque licence et pour chaque poste de travail :

• Connectez-vous à l'ordinateur sur lequel vous voulez activer la licence.
• Lancez Agilitest et cliquez sur la bannière d'activation de la licence en haut de l'écran.

• Affichage de la popup d'activation de la licence

• Saisissez votre identifiant de compte dans le champ "Créer ou modifier votre identifiant de compte".
• Cliquez sur "Modifier le compte".
• Si le nombre de licences activées est inférieur au nombre de licences que vous avez commandées, l'activation devrait être effective :

• Si vous cliquez sur Aide en haut à droite, vous devriez voir apparaître les informations d'activation (nom de la machine, nom de l'utilisateur, identifiant du système, identifiant du client, courriel, société et date d'expiration).

Si l'activation n'est pas effectuée, veuillez contacter notre service commercial ou envoyer une demande à : contact@agilitest.com.

Vous pouvez également nous contacter si vous avez activé une licence sur une mauvaise extension ou si vous souhaitez changer d'extension.

Vous avez la possibilité de supprimer vos scripts ATS via le menu contextuel du clic droit de la souris directement depuis l'arborescence des fichiers de l'explorateur proposé par Agilitest.

Méthode pour récupérer un script

Une fenêtre de confirmation de cette suppression vous est alors proposée :

(Ce dernier vous informe que le script ATS supprimé sera envoyé dans la corbeille du système Windows).

Si cette suppression était une erreur, vous pouvez simplement restaurer ledit fichier via la corbeille du système Windows.

Cliquez sur votre projet ATS dans Agilitest pour mettre à jour son contenu et le script ATS restauré sera à nouveau affiché :

Vous pouvez ensuite le modifier, le lancer, etc., comme s'il n'avait pas été supprimé.

Comment configurer Agilitest sur Internet Explorer 11

Afin de vous permettre d'utiliser Agilitest sur Internet Explorer 11 (disponible en version bêta), il sera nécessaire de configurer les options de sécurité suivantes comme prérequis :

Veuillez ouvrir les"Options Internet" de votre système Windows :

Sélectionnez ensuite l'onglet "Sécurité" dans les "Propriétés de : Internet"

• Décochez l'option "Activer le mode protégé (redémarrage d'Internet Explorer requis)" sur chacune des zones proposées
• Internet
• Intranet local
• Site de confiance
• Sites sensibles

Appliquez les modifications et cliquez sur "OK" dans la fenêtre d'avertissement :

Un redémarrage du navigateur Internet Explorer est nécessaire pour prendre en compte ces modifications.

Certaines pages HTML incluent des iFrames (cadres en ligne) dans leur conception, notamment pour insérer dans la page des éléments provenant d'un autre serveur.

Comment identifier les éléments iFrames

Pour trouver des éléments sur ces pages HTML, vous devrez sélectionner chaque iFrame dans le DOM de la page, sinon vous ne pourrez pas trouver les enfants de cette IFRAME sur la page.

Exemple ci-dessous :

• Sélectionnez l'attribut iFrame qui vous permet de le reconnaître :

• Sélectionnez les attributs des enfants que vous souhaitez retrouver automatiquement dans cet iFrame :

L'objet est alors reconnu sans problème.

Note :

Si l'iFrame n'est pas identifiée, le résultat sera négatif pour détecter ses enfants aussi précisément que la sélection des attributs.

Agilitest est capable de générer un fichier XML contenant toutes les informations importantes sur le déroulement du test, ainsi que les images successives des différentes actions réalisées. Nous avons choisi de nous appuyer sur un format ouvert (.xml) et un moteur de génération de documents sous licence libre (FOP).

Ces fichiers .xml peuvent être utilisés pour produire tous types de rapports :

1. Rapports d'exécution :

- Rapport d'exécution: pour une lecture globale de l'exécution des tests

- Rapport d'exécution détaillé (avec ou sans capture d'écran): pour analyser les raisons de l'échec des tests.

◦ Rapport de synthèse (pdf) : pour une lecture globale de la réussite des tests dans un format spécialisé.

◦ Rapport ATSV: Images d'exécution compilées dans un format vidéo (lues via le lecteur ATSV).

‍

     2. Rapport de validation: pour documenter et archiver les exécutions mises en œuvre.

‍

Vous trouverez ci-dessous un schéma d'utilisation des rapports en fonction des besoins des équipes et de la manière dont l'organisation de l'information peut être utilisée (ainsi qu'une vidéo d'animation du schéma https://youtu.be/2UdsYINPk_s).

Configurations

Génération de rapports

Il est possible de configurer les informations que vous souhaitez voir apparaître dans vos rapports (d'exécution ou de validation) depuis le constructeur du projet en cochant la case "Générer un rapport" ou depuis votre intégration Jenkins. Vous pourrez choisir de générer des rapports d'exécution ou un rapport de validation.

Depuis l'interface d'exécution

Il y a deux façons possibles de générer des rapports :

1. Dans le menu déroulant de votre projet, en cliquant sur "Paramètres d'exécution"

‍

Puis en cliquant sur la case "Générer un rapport"dans le constructeur du projet. Cela vous donnera accès au "Niveau de détail du rapport"ainsi qu'à la possibilité de cocher la case "Générer un rapport de validation".

2. Depuis le menu de "gestion de canal" en sélectionnant le menu "Paramètres" et ensuite "Générer un rapport XML"

Depuis votre intégration Jenkins

La configuration des rapports peut également être effectuée à partir de l'intégration Jenkins lors de la création d'une tâche Jenkins.

Vous pouvez définir le niveau du rapport d'exécution ou générer un rapport de validation à partir d'une case dédiée dans la fenêtre de création de Job Jenkins.

‍

Archivage des rapports

À la fin de l'exécution, les rapports seront archivés dans l'un de ces fichiers par défaut :

Rapport généré par Agilitest ;

• Java : <Agilitest_project_file>\<project_name>\target\ats-output
• Maven : <Agilitest_project_file>\<project_name>\target\surefire-reports
• Ou placé selon le choix de l'utilisateur

Rapport généré par l'intégration Jenkins :

• Jenkins : <jenkins_job_folder>\builds\<numero_de_build>\htmlreports\<nom_du_publisher>\

Rapports d'exécution

Le niveau d'information dans les rapports d'exécution peut être choisi dans Agilitest en utilisant le menu déroulant "Niveau de détail du rapport".

Les rapports d'exécution fournissent trois niveaux d'information à partir du constructeur du projet dans l'éditeur Agilitest.

Chaque niveau de rapport comporte les en-têtes suivants :

• Un résumé global de la suite exécutée avec une description, les paramètres ajoutés et le résultat de l'exécution.
• Un résumé par Suite qui comprend le nombre de tests exécutés
• Un résumé par script avec le nombre d'actions, l'heure et la date de l'exécution du script, l'auteur, un lien vers le rapport vidéo et le résultat de l'exécution.

Rapport d'exécution

Le rapport d'exécution fournit une lecture globale de l'exécution des tests. Il indique :

• Actions
• Liens externes
• Temps d'exécution
• Le statut de l'exécution de l'action

Rapport d'exécution détaillé (avec ou sans captures d'écran)

Le rapport d'exécution détaillé permet de mieux comprendre la conception des tests et des éventuels bugs. Il indique :

• Actions
• Liens externes
• Temps d'exécution
• Le statut de l'exécution de l'action
• Informations sur l'action
• Une capture d'écran cliquable et zoomable (pour le rapport avec capture d'écran)

Toutes les informations sur les actions spécifient le type d'action et les éléments de l'action. Exemple : ActionMouseKey, Type : Clic.

Un insert violet correspondant à l'action apparaîtra dans l'image lorsqu'une action exécutée correspond à une interaction de l'utilisateur (exemple : actions de la souris, saisie de texte, etc...).

Lorsqu'une action échoue ou n'est pas validée mais n'empêche pas le succès du test, une explication de l'erreur apparaîtra dans la partie information de l'action.

‍

‍

Le rapport vidéo : ATSV

Le fichier ATSV est accessible directement depuis les rapports d'exécution et correspond à un format vidéo du rapport présenté comme un ensemble d'images compilées accompagnées d'animations des actions exécutées. Pour l'instant, le format de fichier n'est utilisable que via Agilitest et son lecteur interne (Prochainement : le lecteur s'ouvrira sur une page web)

Le fichier ATSV est également accessible à partir des paramètres d'exécution en cliquant sur "Rapport vidéo".

Rapport de synthèse

Le rapport de synthèse est généré directement à partir du rapport d'exécution au format PDF. Il nécessite l'utilisation de l'outil Jasper pour être généré. Il est consulté par les managers et les équipes de projet pour disposer d'un compte rendu des tests exécutés dans un format spécialisé. Il correspond à un résumé par Suite d'exécution et par test afin d'avoir un état global de l'assurance qualité du logiciel.

Directement à partir du rapport d'exécution, cliquez sur le lien Résumé pour générer le fichier PDF (en haut à droite du rapport d'exécution).

L'affichage de vos rapports de synthèse peut être personnalisé grâce à des modèles de rapports de projet.

Pour y accéder, ouvrez les propriétés de votre projet en cliquant sur le menu Burger situé dans l'explorateur de projet

Choisissez ensuite le modèle que vous voulez utiliser dans la boîte dédiée.

Le rapport de validation

Le rapport de validation est généré en cochant la case "Générer un rapport de validation" dans le constructeur du projet :

Le rapport de validation est conçu comme une preuve d'exécution à sauvegarder ou à archiver.

Il comprend les mêmes informations que le rapport d'exécution détaillé avec capture d'écran cliquable, à l'exception de ce qui suit :

• Il n'a pas de lien,
• Il y a toutes les actions (temps d'exécution, état d'exécution de l'action) sauf celles-ci : pas d'ActionChannel ni d'ActionProperty et d'ActionComment,
• Dans la partie information, il n'y a pas de partie "erreur" et dans la partie "élément", on retrouve le Tag et les Critères mais on ne retrouve pas le nombre d'éléments trouvés, le temps de recherche, la localisation, la position du clic.

L'état d'exécution de l'action

Pour tous les rapports d'exécution et pour le rapport de validation, il existe trois états d'exécution :

‍

Action en erreur : Lorsqu'une action est en erreur pour diverses raisons (bugs, mauvaise saisie, etc...) l'icône d'erreur apparaîtra sur la ligne de l'action.

‍

Action réussie : Lorsqu'une action est réussie, l'icône de validité apparaît sur la ligne de l'action.

‍

‍

Action qui a échoué mais qui passe : Lorsqu'une action est en erreur mais n'empêche pas la poursuite de l'exécution du test, l'icône d'erreur de passage apparaît sur la ligne de l'action.

‍

‍

Le statut de vérification de l'action

Pour les rapports d'exécution détaillés et le rapport de validation, dans la case "information", les éléments d'une action validée sont indiqués en vert.

Pour les rapports d'exécution détaillés et le rapport de validation, dans la case "information", les éléments qui mettent une action en erreur sont indiqués en rouge.

‍

‍

Agilitest supporte l'automatisation des tests sur les appareils Android.

Conditions préalables sur le terminal Android

• Activez le mode développeur du smartphone pour permettre le "débogage USB".

1. Allez dans les paramètres.
2. Tout en bas, allez dans"À propos de l'appareil" (ou dans"Système - À propos de l'appareil", sur certains modèles).
3. Presse la case Build Number plusieurs fois (sept fois) jusqu'à ce qu'un message apparaisse"You are now a developer". Vous venez d'activer le mode développeur sur Android.
4. Revenez au menu principal des paramètres, vous verrez alors un nouveau sous-menu :"Options pour les développeurs" ou"Options de développement" selon la personnalisation du fabricant.
5.  Dans les options du développeur, activez"Débogage USB".
6. Désactivez toutes les fonctions de verrouillage automatique de l'écran.
7. Connectez le terminal Android sur USB.
8. Connectez le terminal Android au même réseau WiFi que celui auquel vous connectez l'Agilitest.

• Sous Windows 7, installez le pilote de développement fourni par le fabricant de votre téléphone. Par exemple, voici le pilote pour les appareils Samsung. Après avoir installé le pilote, une ligne "Android ADB Interface" apparaît dans le Gestionnaire de périphériques de Windows en connectant le téléphone via USB.

Conditions préalables sur Agilitest

• Dans le menu "Aide", cliquez sur le lien dédié au téléchargement de "AtsMobileStation" en accord avec votre OS (Windows ou Mac OS)

• Exécutez le paquet téléchargé "AtsMobileStation.exe ou .dmg" pour installer localement ce module de détection de dispositifs mobiles.

Début de l'automatisation des tests

Lancez ATS Mobile Station. Le premier écran affiche qu'aucun appareil n'a été trouvé, mais le système commence à scanner les ports USB. Si cet écran persiste, assurez-vous que vous avez connecté votre appareil Android au port USB de votre PC et qu'il est en mode développeur.

ATS MobileStation vient de découvrir un appareil Android connecté et est en train de configurer la connexion.

Enfin, le terminal est trouvé, configuré et prêt à être utilisé. Obtenez l'adresse IP du terminal connecté pour la saisir dans Agilitest.

Dans Agilitest, créez le script ATS qui vous convient et insérez l'action"Démarrer canal" et sélectionnez"Mobile".

Entrez l'adresse IP du terminal connecté, cliquez sur"Découvrir" puis sélectionnez l'application installée que vous souhaitez lancer automatiquement :
Cliquez sur"Ok" pour finaliser l'appairage.

L'action d'ouverture de l'application mobile est configurée dans Agilitest.

L'activation de la capture dans Agilitest ouvre une visualisation à distance de l'écran du terminal contrôlé afin d'automatiser directement dessus les actions souhaitées.

Sauvegarde des paramètres de lancement d'une application mobile

Vous pouvez enregistrer ce paramètre pour lancer l 'application souhaitée dans vos paramètres ATS comme suit :

Cliquez sur le bouton"Paramètres" en haut à droite.

Cliquez sur le bouton"Editer la configuration" (cela ouvre le fichier .atsProperties dans votre éditeur de texte par défaut)

Remplir le fichier de configuration en nommant l'application et en remplissant l'URL précédemment définie

<mobiles>
<mobile>
<name>Betclic</name>
<url>mobile://192.168.0.39:8080/sport.android.betclic.fr</url>
<waitAction>100</waitAction>
</mobile>
</mobiles>

ATS Les options de configuration sont directement accessibles depuis le panneau de contrôle de l'Agiltiest et certains menus(notamment dans les exécutions).

Comment configurer ATS?

Il est également possible de configurer certaines des fonctions de l'éditeur AGILITEST via le fichier de configuration .atsProperties accessible directement depuis l'éditeur via le menu "Paramètres" > bouton "Editer la configuration".

Les paramètres actuellement autorisés sont les suivants :

• Nombre par défaut d'exécutions de chaque action dans l'éditeur avant de décider d'un échec : par défaut, fixé à 10.

<maxTry>16</maxTry>

• Positionnement des fenêtres ouvertes automatiquement par l'éditeur : coordonnées par défaut du coin supérieur gauche fixées à x=20 et y=20
• Dimensionnement des fenêtres ouvertes automatiquement par l'éditeur : largeur et hauteur fixées par défaut à 1500 x 960

<appBounding>
<x>20</x>
<y>20</y>
<width>1500</width>
<height>960</height>
</appBounding>

• Gestion du"timeOut" sur l'exécution des scripts et le chargement des pages web : fixé par défaut à 60ms et 120ms

<timeOut>
<script>60</script>
<pageLoad>120</pageLoad>
</timeOut>

• Gestion des chemins d'accès aux différents navigateurs et des horaires spécifiques pour chacun d'eux :

<browsers>
<browser>
<name>opera</name>
<path>C:\Program Files\Opera\52.0.2871.40\opera.exe</path>
<actionWait>50</actionWait>
</browser>
<browser>
<name>firefox</name>
<path>C:\Program Files (x86)\Mozilla Firefox\firefox.exe</path>
<actionWait>200</actionWait>
</browser>
</browsers>

• Gestion des chemins d'accès aux différentes applications debureau Windows installées sur le poste client : Un raccourci sera automatiquement créé dans la partie "app" des actions "Start canal" d'AGILITEST.

<applications>
<application>
<name>notepad++</name>
<path>C:\Program Files\Notepad++\notepad++.exe</path>
</application>
</applications>

‍

Les chemins d'accès devront être adaptés en fonction de votre configuration.

Agilitest vous permet d'utiliser un formatage avancé des commentaires directement à partir de l'éditeur.

Le format utilisé est le HTML, vous pouvez donc concevoir vos commentaires comme vous le souhaitez.

En outre, vous pouvez utiliser les variables de vos scripts pour faire des commentaires intelligents.

Il existe trois types de commentaires :

• Commentaire de script
• Étape fonctionnelle
• Journal d'exécution

Commentaire de script

Ce commentaire explique les opérations effectuées par le script, à l'intention de ceux qui devront notamment le consulter pour le maintenir .

Commentaires de type "étape fonctionnelle".

Ces commentaires indiquent une étape importante dans le déroulement du test.

Ils sont inclus dans la vidéo et les fichiers de rapport XML / pdf.

Commentaires de type "Journal d'exécution".

Il s'agit de commentaires fonctionnels pour les testeurs.

Échantillons

1. Caractères gras
2. Caractères soulignés
3. Caractères italiques
4. Utilisation des puces
5. Utiliser des paragraphes numérotés
6. Liens actifs cliquables
7. Montrer une capture d'écran

Vous trouverez ci-dessous quelques exemples de ces formats HTML de chaines de caractères autorisés avec Agilitest :

• Caractères gras :

<b> Bold characters </b>

• Caractères soulignés :

<u> Underlined characters </u>

• Caractères italiques :

<i> Italic characters </i>

• Utilisation des balles:

<UL> <LI> Using bullets  N°1</LI><LI>Using bullets  N°2</LI></UL>

• Classé par ordre de priorité en paragraphes numérotés : :

<OL><LI>Numéro 1</LI><LI>Numéro 2</LI></OL>

• Insérez un lien actif cliquable (vers un logiciel de suivi bug comme Jira ou Bugzilla):

<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1431248">Bug 1431248</a>

• Insérez et affichez un lien vers une capture d'écran (qui illustrerait l'erreur à corriger):

<img src="https://bugzilla.mozilla.org/attachment.cgi?id=8943437" width="300" height="110"/>

• Un exemple de commentaire avancé dans l'éditeur :

Avertissement concernant les attributs texte

Nous recommandons d'utiliser les attributs "text" d'un élément sur lequel vous voulez automatiser une action uniquement lorsque vous ne pouvez pas faire autrement pour les raisons suivantes :

• La reconnaissance de l'élément ne fonctionne plus dans un contexte multilingue de votre solution.
• Certains navigateurs sont sensibles à la casse (et d'autres non), donc une lettre majuscule tend à diminuer la robustesse et la portabilité de votre test.
• La gestion des sauts de ligne et/ou des espaces peut différer d'un navigateur à l'autre.

Cependant, ces attributs "text" seront les seuls attributs disponibles pour reconnaître un élément.

Une fois que vous avez sélectionné l'attribut "text", vous pouvez cliquer dessus pour en éditer le contenu : nous avons ajouté quelques options vous permettant une édition automatique des valeurs avec des expressions régulières utiles pour éviter ces derniers problèmes.

Après activation : les espaces sont remplacés par des \s* et la chaîne de caractère commence par ( ? i)

Par la suite, AGILITEST ne prendra pas en compte les espaces et la casse sur ces éléments de reconnaissance quels que soient les navigateurs utilisés pour augmenter encore la robustesse de vos tests fonctionnels automatisés.

Que faire lorsque mon éditeur AGILITEST ne me permet pas d'ouvrir un test et de capturer canal: rien ne se passe lorsque j'ouvre un canal.

Types de problèmes d'ouverture du site canal

Si c'est un problème de JDK, alors :

• Suivez le guide de l'utilisateur dédié disponible dans la section Guide de l'utilisateur - Première installation pour vérifier que le Java a été installé.

S'il s'agit d'un problème de pilotes et/ou de bibliothèques (fichier bloqué par le pare-feu ou l'antivirus), dans ce cas il y a deux solutions possibles :

1- Répétez l'opération en s'assurant que le blocage ne se répète pas (neutralisation temporaire de l'antivirus)

• Fermer Agilitest
• Accéder au dossier utilisateur de votre machine pour supprimer manuellement les dossiers "drivers" et "libs".

• Ré-ouvrir Agilitest pour forcer une régénération des fichiers avec les dernières versions disponibles dans SAAS

2- Utilisez la fonction de téléchargement manuel des paquets pour les déployer vous-même dans les répertoires suivants :

• Via le menu "Configurations", télécharger le paquet zippé de Drivers et Librairies

• L'archive "ats.zip " sera automatiquement téléchargée via votre navigateur par défaut.

• Décompresser cette archive "ats.zip " qui contient les dossiers" drivers" et" libs" dans votre propre dossier utilisateur.
• C:\User\Votre_compte\.actiontestscript

L'une des caractéristiques d'Agilitest est la possibilité d'utiliser des sous-scripts. Cela vous permettra de factoriser les fonctions communes de vos tests. Agilitest vous permet également de passer des valeurs comme paramètres à vos sous-scripts et ainsi rendre vos sous-scripts évolutifs et génériques.

Un sous-script créé à partir d'un script exécutera toujours les actions dont il est composé avec les mêmes paramètres.

Il est également possible de modifier les valeurs du sous-script pour l'utiliser dans plusieurs configurations possibles.

Il existe différentes façons de passer des paramètres à un sous-script : :

1. Manuellement, en entrant les paramètres dans le script
2. ou avec un jeu de données, en utilisant un fichier CSV/JSON

‍

▶️ Vous pouvez trouver un tutoriel en 3 parties sur le passage de paramètres à un indice sur notre Youtube canal : Partie 1, Partie 2, Partie 3

‍

Ajouter des paramètres à un sous-script

Si votre script ne comporte pas d'action d'appel sous-script, vous pouvez en créer une de deux façons :

1. Soit en saisissant le nom du sous-script dans l'action

Pour ce faire, cliquez sur le bouton "sous-script" dans le menu d'action

Cliquez sur l'action "Appeler le script [ ]"pour entrer les informations

Ensuite, saisissez le nom du script que vous souhaitez appeler en tant que sous-script.

      2. Soit en glissant un script dans votre test

Dans l'explorateur de projet, cliquez sur un script que vous voulez utiliser comme sous-script et faites-le glisser dans votre script.

Cela créera une action "Appeler le script" avec le script glissé.

‍

1. Paramètres saisis manuellement

Il est possible de passer des paramètres manuellement.

Une fois que vous avez créé l'action d'appel de sous-script dans votre script, vous pouvez passer des paramètres manuellement à votre sous-script, directement depuis votre script.

Pour ce faire, cliquez sur l'action d'appel de sous-script, "Appeler le script [nom_scirpt]."

Ensuite, cliquez sur "ajouter un paramètre"

Pour information, le premier paramètre sera toujours nommé "Paramètre 0", puis le deuxième paramètre correspondra au "Paramètre 1", le troisième paramètre au "Paramètre 2", etc...

Une fois que vous avez saisi les paramètres dans le script, vous devez les ajouter dans le sous-script.

Pour ce faire, ouvrez votre sous-script à partir de l'explorateur de projet.

À partir de votre sous-script, cliquez sur l'action qui exécutera les paramètres et ouvrez ensuite la fenêtre des valeurs spéciales.

Sélectionnez "Paramètre de script" dans les valeurs spéciales et choisissez le paramètre qui vous intéresse.

Lorsque l'action d'appel à un sous-script est exécutée, elle exécute les paramètres spécifiés.

‍

📙 Pour en savoir plus

Avec l'action d'appel de script, un script va appeler un sous-script. Si le script a des paramètres définis, le sous-script les récupère et les passe à $param(x)(voir le schéma ci-dessus "Passer des paramètres à un sous-script depuis un script").

‍

Pendant l'exécution, les paramètres seront affichés dans une fenêtre pop-up en bas à droite de l'éditeur.

Pour votre information, pour faire réapparaître la pop-up indiquant les paramètres, vous pouvez cliquer sur le bouton"\x".

Lorsque les paramètres sont saisis manuellement, l'exécution de vos paramètres ne se fera qu'une seule fois. Pour multiplier les itérations, vous devrez créer autant d'actions d'appel de script que le nombre d'itérations que vous souhaitez voir exécuter. En d'autres termes, vous devrez répéter les étapes précédentes pour chaque nouvelle itération.

‍

💡 Conseil

Ajoutez des commentaires à vos paramètres afin de suivre les données et d'étiqueter les paramètres. Ces commentaires seront visibles dans le rapport d'exécution.

‍

2. Paramètres saisis à partir d'un fichier JSON/CSV

Créer un fichier JSON/CSV

Il est également possible de passer des paramètres à partir d'un fichier JSON/CSV. Un fichier JSON/CSV correspond à un jeu de données. Le jeu de données va permettre de créer des itérations. Le comportement du sous-script sur un jeu de données sera de boucler le nombre d'itérations contenues dans le jeu de données.

Contrairement à une saisie manuelle, où vous auriez dû créer plusieurs fois l'action d'appel de scripts et saisir les paramètres à chaque fois, pour le jeu de données, les paramètres seront organisés dans un tableau qui sera utilisé par une seule action d'appel de script.

Il existe deux façons de créer un fichier JSON/CSV :

1. Cliquez sur "Nouveau composant" situé en haut à gauche de l'éditeur Agilitest.

Puis sélectionnez "Créer un fichier CSV"ou "Créer un fichier JSON"

‍

2. Dans l'explorateur de projet, ouvrez le dossier "assets"et ensuite le fichier "données".

Enfin, faites un clic droit pour créer un fichier JSON ou CSV à partir du menu déroulant.

‍

Une fois le fichier CSV/JSON créé, il peut être utilisé à partir de l'action du script d'appel.

Pour associer votre fichier JSON/CSV à votre script, cliquez sur l'action  "Appeler le script [nom_du_script]"

Sélectionnez fichier "CSV/JSON"

Il y a deux façons d'ajouter votre fichier CSV/JSON dans l'action :

1. Directement à partir de l'explorateur de projet

Faites glisser votre fichier CSV/JSON de l'explorateur de projet vers l'action.

‍

        2. En sélectionnant le fichier dans l'explorateur Windows

Cliquez sur l'icône de fichier pour rechercher votre fichier à partir de l'explorateur Windows.

Une fois que le fichier CSV/JSON est ajouté à l'action d'appel du sous-script, il s'ouvrira automatiquement pendant l'exécution de votre test.

Les fichiers CSV/JSON se présentent sous la forme d'un tableau.

Ils sont tous deux utilisés de la même manière, à la seule différence qu'il est possible de renommer les entêtes de colonnes dans un fichier JSON.

Dans le tableau, vous pouvez ajouter des colonnes qui correspondent aux paramètres, ainsi que des lignes qui correspondent aux itérations en cliquant sur les boutons correspondants.

Avec un fichier CSV/JSON, le sous-script est exécuté autant de fois qu'il y a d'itérations.

‍

📙 Pour en savoir plus

Les paramètres du sous-script sont définis à partir d'un fichier CSV (comma-separated values) constitué d'un tableau avec des lignes et des colonnes. En fonction du nombre de lignes, cela détermine le nombre de fois que le fichier sera appelé, c'est ce qu'on appelle des itérations. (Voir le schéma ci-dessus "Passage de paramètres à un sous-script avec un fichier CSV")

Il en va de même pour les paramètres du sous-script défini à partir d'un fichier JSON (JavaScript Object Notation) composé d'un tableau de lignes (rows) et de colonnes (columns). En fonction du nombre de lignes, cela détermine le nombre de fois que le fichier sera appelé, c'est ce qu'on appelle des itérations. (voir le schéma ci-dessus "Passage de paramètres à un sous-script avec un fichier JSON")

Pour un fichier JSON complexe, il est composé d'un tableau avec des lignes et des colonnes comme un fichier JSON classique. Seulement, les itérations se font en fonction du nombre de valeurs dans une ligne. Le nombre de valeurs dans une ligne correspond au nombre de paramètres (Voir le schéma ci-dessus "Passage de paramètres à un sous-script avec un fichier JSON complexe").

Les paramètres peuvent être créés à partir d'un fichier http ou d'une base de données à partir d'une page web. Le principe est le même que pour un fichier JSON/CSV, les itérations correspondent au nombre de lignes et les paramètres au nombre de colonnes (voir le schéma ci-dessus "Passage de paramètres à un sous-script avec un fichier http").

‍

Options d'exécution des fichiers CSV/JSON

Une fois le jeu de données créé, vous pouvez ajouter des options sur l'exécution de vos fichiers CSV/JSON. Par défaut, les itérations sont faites selon l'ordre présenté dans le tableau, mais il est possible de demander à Agilitest de rendre l'exécution de vos itérations aléatoires.

Pour ce faire, cliquez sur votre élément et cochez la case "Utiliser une ligne aléatoire"

Vous pouvez également donner une "Plage d'index", ce qui vous permet de limiter le nombre d'itérations parmi le total des itérations qui composent le fichier JSON ou CSV.

Si vous le souhaitez, cette option vous permet également d'exécuter une seule ligne précise en indiquant son numéro.

Exemple : Si votre fichier JSON est composé de 150 itérations, vous pouvez spécifier 0-50 dans la plage d'index pour limiter l'exécution aux 50 premières itérations.

Enfin, vous avez l'option "Exécuter comme suite" pour que l'exécution se poursuive jusqu'à la fin même si une itération est en erreur.

Si vous rencontrez une erreur dans l'une des itérations, cela entraînera une erreur dans votre test, et donc l'arrêt du test en le considérant comme KO. Cette option vous permet de considérer chaque itération comme un test indépendant.

Exemple : Sur une exécution de 50 itérations, si la 48ème itération rencontre une erreur, elle sera indiquée comme étant en erreur mais n'empêchera pas de passer à la 49ème et ainsi de suite.

‍

3. Paramètres d'un élément d'interface

Il est possible de ne faire apparaître qu'un seul élément de vos paramètres. Dans un indice complet, si l'une des actions n'a pas d'élément alors le param(0) sera utilisé par défaut. Pour renseigner le param(0) qui sera utilisé, vous pouvez ajouter un"Texte de l'élément" à l'action qui appelle l'indice.

Depuis l'action d'appel de script, cliquez sur "Texte de l'élément".

Ajoutez ensuite un élément sélectionné avec l'outil de capture.

Lorsque vous exécutez votre sous-script, il affiche l'élément que vous avez capturé.

Ceci est particulièrement utile lorsque vous recherchez des données dans votre tableau parmi un ensemble de lignes. Agilitest vous permettra d'itérer jusqu'à ce que vous arriviez à la ligne que vous recherchiez et vous permettra d'effectuer une action spécifique sur cette ligne.

Exemple : Vous avez un tableau qui contient 5 lignes différentes. En donnant le composant "table" en entrée du sous-script, Agilitest va parcourir en boucle les lignes du tableau dans l'indice.

‍

📙 Pour en savoir plus

Les paramètres peuvent également être extraits d'éléments. Pour une liste d'éléments (DIV), chaque élément correspond à une itération et chaque valeur séparée d'une propriété texte "\n" correspond à un paramètre.(Voir le schéma ci-dessus "Passage de paramètres à un sous-script avec une liste d'éléments (div)")

Pour une liste complexe d'éléments (Rows), chaque ligne correspond à une itération et chaque valeur distincte d'un texte divisé "\t" correspond à un paramètre. (voir le schéma ci-dessus "Passage de paramètres à un sous-script avec une liste d'éléments complexes (rows)")

Pour une liste d'éléments spéciaux, chacun de ses éléments a des sous-éléments qui ont eux-mêmes des valeurs. Le nombre d'itérations est déterminé par le nombre de sous-éléments et le nombre de paramètres est déterminé par les valeurs de propriétés texte distinctes qui composent ces sous-éléments. (Voir le schéma ci-dessus "Passage de paramètres à un sous-script avec une liste d'éléments spéciaux")

‍

Options d'exécution des paramètres

Itérations

L'ajout d'itérations permettra à votre script d'être exécuté plusieurs fois. C'est pratique lorsque vous avez une fonction qui peut être utilisée successivement et cela vous permettra de vérifier les comportements de votre interface utilisateur.

Exemple : La fonction "retour en arrière" pour revenir aux pages précédentes d'une page web qui peut souvent être répétée plusieurs fois.

Pour ajouter des itérations à un sous-script composé de paramètrescliquez sur l'appel de votre indice et augmentez le nombre d'itérations.

Exemple : Si vous ajoutez 3 itérations, l'indice et ses paramètres seront exécutés 3 fois.

L'ajout d'itérations vous permet d'éviter flaky tests, c'est-à-dire les actions qui sont exécutées plusieurs fois et qui produisent parfois une erreur sans raison particulière.

Les itérations, les conditions et les variables ne sont pas toujours utilisables selon le cas:

• L'exécution du sous-script à partir des paramètres ajoutés depuis votre script vous donnera accès à toutes les options disponibles : itérations, variables et conditions.
• L'exécution du sous-script à partir d'un fichier JSON ou CSV ne vous permettra pas d'utiliser des variables ou des itérations mais vous permettra d' ajouter des conditions.
• L'exécution du sous-script avec l'ajout du texte d'un élément vous permettra d'ajouter des itérations et des conditions mais ne vous donnera pas accès aux variables.

‍

Valeur de retour

Il est possible d'obtenir des données à partir d'un sous-script. Cela créera une variable dynamique (non modifiable) puisque la variable de retour valorisera automatiquement la variable du script principal.

Il y a deux façons d'obtenir une valeur retournée :

1. Créer une variable

Tout en bas du sous-script se trouve une petite flèche jaune qui vous permet d'ajouter une valeur de retour.

Une fois que la variable de retour a été créée, elle doit être récupérée dans l'action d'appel de script.

Pour ce faire, cliquez sur le bouton "Variables" pour la tagger dans le script principal avec une variable équivalente en face.

‍

2. Variable de propriété

Créez une action de propriété pour obtenir des données depuis l'interface.

Pour ce faire, cliquez sur "Propriété" dans le menu d'action

L'action de propriété ciblera un élément d'interface.

Pour cela, cliquez sur le bouton "Charger"dans l'action de la propriété

Elle va charger toutes les propriétés qui sont associées à cet élément.

Cliquez sur la propriété qui vous intéresse pour qu'elle soit chargée pendant l'exécution.

Ces propriétés correspondent aux attributs de l'élément qui se trouvent dans la fenêtre "Parents de l'élément capturé" lorsque l'élément est capturé.

Des propriétés ATS apparaissent également dans la liste des propriétés ainsi que les éléments de mise en forme (CSS).

Lorsqu'une propriété est sélectionnée, elle est placée dans une variable qui prend la valeur de la propriété sélectionnée.

Exemple: Si vous sélectionnez la propriété "texte"avec la valeur "Hello world - Wikipedia" dans la liste des propriétés capturées.

Une fois que la valeur est créée à partir de la propriété, vous pouvez la retourner.

Cliquez sur le bouton "Ajouter une valeur de retour"

Ensuite, ouvrez le menu des valeurs spéciales et sélectionnez dans les variables de script celle qui correspond à la variable de propriété

Cliquez sur l'action d'appel du sous-script, puis sur "Variables" pour spécifier qu'une valeur est renvoyée par le sous-script.

Sélectionnez la variable qui stockera cette valeur de retour parmi celles déjà créées ou vous pouvez également en créer une nouvelle.

Cela signifie que la valeur de retour du sous-script sera récupérée dans les variables du script principal.

Cela permet de faire passer des données entre un script et ses sous-scripts.

‍

📙 Pour en savoir plus

Le script principal appelle un sous-script qui contient des valeurs. Il est possible de passer des paramètres à ce sous-script et il est également possible de renvoyer les valeurs du sous-script au script principal. Avec l'action retour de valeur, vous pouvez appeler un certain nombre de valeurs qui seront retournées en fonction des valeurs contenues dans le sous-script. Parfois, les informations envoyées (paramètres ou valeurs de retour) ne sont pas attendues et ne sont donc pas traitées.

‍

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur la gestion de canal :

‍

Nous faisons la distinction entre les actions pour gérer les canaux dans les ATS scripts , qui fait l'objet de cette documentation et la gestion des canaux dans l'éditeur pour faire des opérations de capture d'éléments graphiques que vous pouvez lire ici .

Dans un script ATS généré par Agilitest, il y a toujours un seul canal actif à un moment donné, et toutes les actions sont dirigées vers ce canal.

Il est donc impératif de lancer un canal avant de créer toute action.

Démarrez un canal

L'action "démarrer un canal" vous permet de sélectionner l'application qu'Agilitest va lancer pour vous, vous avez plusieurs possibilités :

• Ouvrir un navigateur parmi ceux proposés
• Ouvrir un explorateur Windows
• Ouvrir une application de bureau définie dans votre configuration
• Ouvrir une application mobile (Android ou iOS)
• Ouvrir n'importe quelle application .exe.
• Ouvrir un Webservice

Ensuite, il est préférable de renommer le canal que vous avez ouvert afin qu'il puisse être référencé dans les actions suivantes. Pour ce faire, cliquez sur [ex.new-canal].

Changer vers le canal

L'action "changer vers le canal" vous permet de passer à un autre canal identifié par son nom.

À partir de cette action, toutes les actions suivantes seront dirigées vers le site canal spécifié.

ASTUCE : Le démarrage d'un nouveau canal active directement celui-ci.

Fermer un canal

Fermer un canal indique à Agilitest que ce canal ne sera plus utilisé pendant ce test, et fermera l'application.

Connecter un canal à une application déjà lancée

Une petite astuce : si vous voulez connecter un canal à un processus existant déjà dans votre système d'exploitation, vous pouvez utiliser la commande process:// complétée par une expression régulière pour trouver votre processus dans la liste des processus déjà lancés.

Par exemple :

process://.*notepad\+\+\.exe

Menu de gestion de canal

Cette documentation concerne le menu qui permet de gérer les différents canaux d'entrée des actions lors du débogage des tests, un autre article traite des actions de gestion de canal .

Le menu de gestion de canal se trouve à gauche, sous l'explorateur de projets.

Il comporte plusieurs icônes dont les fonctions sont les suivantes :

Capture : Cette action n'est possible que si vous avez déjà ouvert un canal, exécuté l'action ouvrir et éventuellement navigué vers la page ou le web service que vous testez. Elle permet d'entrer en mode capture et de sélectionner les éléments sur lesquels effectuer des actions.

Fermer : Cette action vous permet de fermer proprement un canalouvert, c'est-à-dire de fermer l'application et d'indiquer à Agilitest qu'elle est fermée. Agilitest n'est pas intrusif (pas de plugin), il n'a aucun moyen de savoir que vous avez fermé une application directement par les actions du système d'exploitation (cliquer sur l'icône de la croix de la fenêtre par exemple) . Il est donc impératif de toujours utiliser cette action pour fermer une application ouverte par Agilitest.

Exécuter : Cette action démarre une exécution complète à partir de l'action actuelle. Si vous n'êtes pas sûr d'une action pour démarrer un test, vous obtiendrez le message suivant :

Dans Agilitest, tous les scripts peuvent être des sous-scripts d'autres scripts. Dans l'éditeur, il est impossible pour Agilitest de déterminer le début d'un test, vous devez donc indiquer par quelle action vous voulez commencer votre test dans les phases d'édition et de débogage.

Suivant : Cette action exécute l'action sélectionnée et passe à l'action suivante. Vous pouvez donc exécuter votre test en séquence, étape par étape. Cette action est équivalente à l'action d'exécution de chaque action affichée à droite de l'action courante dans l'éditeur.

Paramètres : Cette action affiche un sous-menu permettant de sélectionner les paramètres d'exécution en cours dans l'éditeur.

• Animer: permet de rejouer le test en animant les actions réalisées (déplacement de la souris, clics, saisie de texte, etc.).
• Rapport visuel: Le rapport visuel a le même résultat que l'animation, mais sous forme de rapport vidéo : un fichier ATSV (ATS Video) est généré dans le répertoire /target/reports. Il n'est pas nécessaire de mettre le replay en mode animation pour obtenir le rapport visuel.

• Exécuter en mode réduit: Cela permet de masquer l'éditeur d'Agilitest pendant l'exécution du test, et ainsi de mieux voir l'application testée. C'est très utile si vous utilisez Agilitest sur un seul écran.

‍

Vous pouvez regarder notre tutoriel ou vous pouvez parcourir notre documentation sur la gestion des fenêtres :

‍

Lorsqu'une application ouvre une fenêtre, Agilitest ne peut pas déterminer si la capture doit avoir lieu sur cette fenêtre ou si elle doit rester sur la fenêtre courante. Cela dépend de la façon dont les concepteurs de l'application ont voulu le faire, si la fenêtre est modale, non-modale, etc.

Nous avons donc ajouté toute une série de fonctions qui permettent de gérer correctement tous les types de situations impliquant des fenêtres multiples, ou des onglets de navigateur, que nous considérerons également comme des fenêtres.

La fenêtre actuelle

Lorsqu'il n'y a qu'une seule fenêtre dans l'application, toutes les actions qui sont effectuées sont envoyées à cette fenêtre. Lorsqu'une application possède plusieurs fenêtres, il faut définir une fenêtre courante. Ceci est très similaire à ce que nous avons fait avec le canal courant : toutes les actions qui sont effectuées sont sur la fenêtre courante.

Les fenêtres concernées sont de véritables fenêtres d'OS : vous pouvez avoir une application Web très complexe qui gère plusieurs fenêtres dans un navigateur sans devoir changer de fenêtre.

Changer la fenêtre actuelle

Cette fonction permet de changer la fenêtre courante en indiquant le numéro de la fenêtre concernée. En général, le numéro 0 correspond à la fenêtre principale de l'application, et les numéros suivants sont dans l'ordre d'apparition des fenêtres (ou des onglets dans un navigateur).

Taille et emplacement

Cette action permet de déplacer la fenêtre en spécifiant ses nouvelles coordonnées cartésiennes, ou de modifier sa taille: hauteur et largeur.

Il vous suffit d'activer les paramètres que vous souhaitez modifier en cliquant sur les étoiles jaunes, puis de saisir les valeurs souhaitées.

Cette action agira sur la fenêtre actuelle.

État de la fenêtre

Cette action vous permettra d'envoyer un événement du système d'exploitation sur la fenêtre actuelle. Elle fonctionne de la même manière que si vous aviez cliqué sur l'une des icônes de votre application, (en haut à droite pour Windows).

Les actions possibles sont les suivantes :

• Fermer : fermer la fenêtre actuelle
• Maximiser : agrandir la fenêtre actuelle au maximum
• Réduire : réduit la fenêtre

Des actions puissantes

Toutes ces actions vous permettront d'agir précisément sur la configuration des fenêtres de votre application.

Dans certains cas, cela peut poser des problèmes :

Le positionnement forcé

Si vous placez les fenêtres de votre application toujours à la même position, il se peut que vous ne voyiez pas bugs dépendant, dans ce cas nous recommandons de laisser les applications utiliser l'espace de l'écran comme elles le souhaitent, et éventuellement de faire les tests sur des écrans de tailles différentes.

Évidemment, dans certains cas, il est utile de forcer une configuration spécifique, si vous utilisez la reconnaissance graphique par exemple, car contrairement à une approche liée à la structure de l'application (DOM, Desktop), la reconnaissance graphique va agir sur les éléments réellement visibles à l'écran.

Intervention directe sur l'application

La fermeture de la fenêtre actuelle permet de se débarrasser d'une fenêtre pop-up encombrante.

Mais nous ne recommandons pas de fermer la fenêtre principale de l'application (sauf si vous voulez contrôler une fenêtre d'alerte).

Pour le faire correctement dans Agilitest, utilisez l'action de fermer le canal .

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur la saisie de texte :

Comment utiliser la saisie de texte

L'action "Saisie de texte" est accessible directement depuis la barre d'outils, ou en déposant un locator dans l'éditeur :

Dans les deux cas, un sous-menu vous permet de saisir le texte souhaité :

Un ensemble de touches supplémentaires vous permet d'utiliser des touches spéciales lors de la saisie de texte.

Vous pouvez utiliser le menu vous permettant d'insérer une valeur spéciale, une variable, etc.

Bien évidemment, pour voir apparaître votre texte dans l'application testée, l'élément d'interface sur lequel vous effectuez cette action doit accepter les saisies de texte au clavier. Cependant, Agilitest ne vous interdira pas de le faire sur un mauvais élément, l'opération finale dépendra toujours de la réaction de votre application.

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur les actions de la souris :

‍

Comment utiliser les actions de la souris

Les actions de la souris sont utilisables pour toutes les applications, y compris pour les applications mobiles (le clic correspond à une tape sur l'écran).

Le menu est accessible directement dans la barre d'outils, ou en déposant un locator dans l'éditeur :

Dans les deux cas, les menus sont identiques.

Les possibilités d'actions sont les suivantes :

Clic de souris

En cliquant sur l'édition de l'action générée, vous avez accès à un sous-menu qui vous permet de sélectionner le type de clic que vous souhaitez générer : clic gauche, molette de défilement, droit, double-clic, et appui sur la touche CONTROL ou SHIFT.

Par défaut, le clic est au centre de l'élément.

Cependant, vous pouvez vouloir cliquer sur une zone décalée ou sur un autre élément dont vous connaissez les coordonnées cartésiennes par rapport à l'élément d'interface sélectionné.

Pour cela, vous pouvez sélectionner un coin, ou un côté de l'élément à partir duquel vous allez spécifier un décalage cartésien.

Les coordonnées positives définissent toujours un point à l'intérieur de l'élément. Par exemple, si vous sélectionnez le coin droit / supérieur et un décalage de 10 en x et 10 en Y, le point du clic se trouvera à l'intérieur de la boîte englobante de l'élément d'interface, à 10 pixels à gauche et en bas du point supérieur / droit.

Survol

Le survol vous permet d'indiquer que vous souhaitez survoler une zone spécifique de l'écran.

Cela vous permet, par exemple, d'activer des menus déroulants.

Dans ce cas, le positionnement en coordonnées cartésiennes fonctionne également.

Glisser, déposer

Les actions de glisser et déposer simulent un mouvement de la souris pendant lequel le bouton gauche de la souris est maintenu enfoncé. Les actions doivent être effectuées dans cet ordre :

• Commencez par une action de glisser en définissant l'élément à partir duquel l'utilisateur souhaite faire partir son clic gauche et maintenir .
• Insérer zéro ou plusieurs actions de balayage : définitions des zones de balayage qui sont visitées par la souris avec le bouton de la souris maintenu enfoncé.
• une action de dépôt en définissant l'élément sur lequel le bouton de la souris est relâché.

Cette action est très souvent utilisée pour effectuer des opérations de glisser-déposer entre plusieurs fenêtres d'une ou plusieurs applications.

Défilement

L'action de défilement simule une rotation de la molette de la souris provoquant le défilement de la page affichée. Dans le cas d'une application mobile, le défilement se traduit par une action de balayage de l'écran (swipe).

Dans les deux cas, Agilitest est utilisé pour indiquer le nombre de pixels de défilement vers le haut ou vers le bas. Ce nombre est positif si l'on veut faire défiler vers le bas.

Pour être efficace, l'élément d'interface sélectionné doit répondre à une action de défilement. Vous pouvez effectuer cette action sur la fenêtre principale de l'application en ne sélectionnant pas d'élément d'interface.

L'action est utilisable sur les sous-fenêtres, DIV, qui ont des options de défilement, en sélectionnant l'élément incluant la fenêtre désirée.

Agilitest automatise la génération de scénarios dans Neoload

Cela vous permet de bénéficier de la capacité d'Agilitest à enregistrer et rejouer un scénario.

Nous avons développé de nouvelles actions ATS spécifiques à Neoload

Voici le détail de ce qui est disponible :

Activation du mode Neoload

Neoload n'est pas activé par défaut dans Agilitest. Pour ce faire, vous devez modifier votre fichier .atsProperties et ajouter les lignes suivantes :

<neoload>
<recorder>
<host>192.168.0.28</host>
<port>8090</port>
</recorder>
<design>
<api>Design/v1/Service.svc</api>
<port>7400</port>
</design>
</neoload>

Les paramètres sont les suivants :

• recorder / host: correspond à l'adresse IP de la machine qui exécute Neoload et qui enregistre les scénarios.
• recorder / port : le port d'écoute de Neoload sur cette machine. La valeur par défaut est 8090.
• design / api : Service d'écoute de l'api Design permettant d'écouter et de modifier le projet Neoload en cours.
• design / port : Port du Servie. La valeur par défaut est 7400.

Une fois cette configuration effectuée, si vous redémarrez Agilitest, vous verrez apparaître un menu Neoload sur la droite de votre écran :

Le menu Neoload est défilable et affiche les sous-menus suivants :

Voici le détail des différentes fonctions disponibles :

Début

Permet de dire à Neoload de démarrer un scénario utilisateur.

La valeur UserPath n'est pas obligatoire mais elle vous permettra de S'inscrire un utilisateur dans votre scénario.

Stop

Indique à Neoload d'arrêter le parcours utilisateur en cours.

Les options disponibles sur l'action :

• Find framework parameters : cette option permet de définir des paramètres de remplacement dans Neoload dans le cadre afin de pouvoir les utiliser lors de la variabilisation.
• Recherche de paramètres génériques : cette option permet de définir des paramètres génériques dans Neoload afin de pouvoir les utiliser lors de la variabilisation.

Conteneur

Cette action crée un conteneur dans Neoload et le nomme.

Enregistrement

Cette action active et désactive l'enregistrement dans Neoload.

Nous allons voir comment automatiser des solutions logicielles développées et compilées sous Windows. Agilitest supporte nativement ces solutions, grâce à un driver Desktop spécifique.

Comment lancer le logiciel ?

Il suffit de créer une action pour ouvrir un canal, puis de cliquer sur l'icône pour sélectionner un fichier .EXE.

Agilitest ouvre alors un explorateur de fichiers vous permettant de sélectionner votre fichier exécutable.

Ensuite, tout fonctionne comme sur les technologies web - vous passez en mode capture pour sélectionner les composants :

En appuyant sur CTRL, vous pouvez sélectionner un composant et afficher la fenêtre de sélection locator :

Dans ce cas, les composants qui sont affichés ne sont pas des éléments du DOM comme sur les navigateurs Web, mais correspondent aux Widgets utilisés pour construire l'interface graphique de l'application de bureau.

L'identification d'un locator pour retrouver de manière unique le composant dans la page fonctionne cependant de la même manière. Dans le cas d'une application de bureau, il peut y avoir un AutomationId généré par le framework du composant utilisé pour développer l'application.

Pour sélectionner un composant de sous-menu, il peut être utile d'utiliser le bouton SHIFT, qui met temporairement en pause le mode capture pour naviguer vers le composant de sous-menu souhaité : Si vous appuyez sur SHIFT, les événements des navigations sont directement envoyés à l'application testée.

Pour créer une action dans Agilitest, il suffit de déposer l'élément dans l'éditeur, à partir de la zone "glisser-déposer dans l'éditeur" du site locator:

Vous créez une action en déposant le composant à l'endroit souhaité dans l'éditeur : à la fin du script ou entre deux actions. Assurez-vous simplement que le menu "Créer une action" est affiché au bon endroit.

L'action saisie par le bureau est alors insérée dans l'éditeur.

Pour aller plus loin

Configuration d'une application couramment utilisée

Vous pouvez configurer une application couramment utilisée en modifiant le fichier de configuration .atsProperties.

L'icône de cette application s 'affichera alors automatiquement dans l'action start canal, vous permettant de l'ouvrir directement.

Utilisation d'un bureau Locator sur une application Web

Le pilote Desktop est toujours actif dans Agilitest, même lorsque vous automatisez des solutions Web.

Cela vous permet de sélectionner des composants spécifiques de l'application .EXE correspondant à votre navigateur.

Si vous souhaitez tester votre application sur plusieurs technologies Web et plusieurs navigateurs, nous vous déconseillons d'utiliser ce mode, car vous pourrez activer des composants non-DOM, spécifiques à votre navigateur, et ainsi provoquer un dysfonctionnement sur d'autres navigateurs.

Pour sélectionner un Desktop Locator sur une application web, il suffit d'appuyer sur le bouton ALT en mode capture : Agilitest passera de la vue DOM à l'affichage du composant Desktop. Vous pouvez également cliquer sur le bouton "Sys (Alt)" en haut de la fenêtre de capture.

Il suffit d'appuyer à nouveau sur ALT pour revenir à la sélection DOM.

Cette fonction est très utile si votre application web permet de télécharger un fichier local vers un serveur web : aucun effort particulier n'est nécessaire pour automatiser cette action.

Certaines configurations de test exigent que vous puissiez récupérer plusieurs éléments du même type avec une seule locator. Il y a plusieurs raisons à cela :

Comptez les éléments

Il est utile de pouvoir compter tous les éléments d'un type donné pour s'assurer sans entrer dans les détails qu'une page, un tableau, une liste, une recherche comporte le bon nombre d'éléments.

Nous allons prendre l'exemple d'un tableau qui affiche les principaux navigateurs et leur portage sur différents systèmes d'exploitation :

Nous allons faire un premier contrôle qui vérifie que le nombre de lignes est égal à 8.

Nous commencerons par sélectionner une ligne, avec un attribut qui nous permet de l'identifier, et nous veillerons à identifier également un de ses parents commun à tous les éléments que nous voulons compter de manière unique (en commençant par celui-ci).

Ensuite, nous faisons glisser l'élément qui suit notre script pour que le contrôle d'occurrence soit égal à 8.

Évidemment, la première tentative de lancer le test à la volée échouera, puisque cet élément est reconnu de manière unique avec son xid = tr5, et donc Agilitest ne trouve qu'une seule occurrence de ligne.

Nous supprimons ensuite l'attribut TR xid = tr5 de l'objet locator

On obtient un locator non exclusif qui permet de trouver toutes les occurrences de TR sous l'élément TABLE table-main

En effectuant l'action à la volée, nous confirmons qu'Agilitest trouve 8 lignes dans ce tableau.

Si vous cliquez sur la loupe :

Agilitest affiche tous les éléments qui correspondent au locator utilisé, ainsi que leur numéro d'ordre d'apparition dans la structure du logiciel testé.

Rechercher un élément par son index

Lorsque l'on dispose de locators qui permettent de trouver plusieurs éléments, il est possible de préciser par un indice celui auquel on souhaite s'adresser.

Vous devez cliquer dans l'éditeur sur l'élément qui est multiple

Puis à droite de l'élément, vous verrez un # et deux contrôles haut/bas qui identifient par un index l'élément défini par votre locator.

En validant, Agilitest vous permet de récupérer des attributs spécifiques d'un élément identifié par son index. Par exemple, nous récupérons le texte de la troisième ligne du tableau ci-dessous.

Pour aller plus loin

Vous pouvez utiliser les index sur plusieurs éléments du même locator.

Cela peut vous permettre par exemple d'aller vérifier le contenu d'une cellule spécifique d'un tableau.

Cette fonctionnalité d'identification d'un élément par son index peut également vous permettre dans certains cas de vous sortir de situations complexes, si vous manquez d'attributs pour sélectionner de manière unique un élément dans une page.

Vous pouvez également apporter plus de robustesse à vos tests, par exemple si vous changez souvent vos données de test, ne pas sélectionner un élément par son contenu mais par son index peut être plus efficace à long terme, mais votre test sera moins déterministe.

Mise à jour régulière

Agilitest est une solution logicielle qui se met automatiquement à jour dès son lancement. Et il y a généralement une nouvelle version chaque semaine.

Notre philosophie est de répondre aux besoins de nos clients et de notre base installée.

De plus, Agilitest supporte les dernières versions des navigateurs, ce qui est absolument nécessaire pour vérifier leurs changements et mettre à jour nos pilotes (voir l'info sur Chrome 74).

ATS et l'éditeur Agilitest

Au lancement, Agilitest commence par mettre à jour la bibliothèque open-source ATS .

ATS est la bibliothèque open-source qui gère toutes les interfaces avec les technologies supportées par Agilitest et rejoue les tests écrits au format ATS .

Cette mise à jour permettra à l'éditeur d'Agilitest d'utiliser la toute dernière version de ATS.

Ensuite, l'éditeur Agilitest se met à jour : un écran d'accueil vous informe qu'une nouvelle version est disponible, et vous propose de la mettre à jour.

Vous voyez également le contenu de la nouvelle version: il comprend les éléments suivants (jusqu'à présent en français) :

Ajouts: Il s'agit de nouvelles fonctionnalités non liées aux fonctions existantes.

Évolutions : Nouvelles fonctionnalités liées aux fonctions existantes et extensions de fonctions

Corrections : Corrections fonctionnelles bug , corrections de fonctionnalités, améliorations techniques.

Vous pouvez refuser la mise à jour

Vous pouvez évidemment refuser la mise à jour, mais sachez que l'impact est assez limité puisqu'il ne concerne que l'éditeur et ses fonctionnalités : la mise à jour de ATS est automatique.

Je veux utiliser une version spécifique de ATS

Il est tout à fait possible de stabiliser l'utilisation d'une version spécifique de ATS en référençant la bibliothèque ATS que vous souhaitez.

Nous ne le recommandons pas car les changements dans l'éditeur et ATS sont étroitement liés, mais nous considérons que cette fonctionnalité peut intéresser certains clients. En général, vous n'aurez peut-être pas accès à certaines fonctionnalités récentes développées dans l'éditeur.

Pour indiquer la version souhaitée de ATS , il suffit de cliquer sur la modification des propriétés d'un projet (icône avec la clé dans le bandeau du projet).

Si vous voulez laisser Agilitest gérer les dépendances et télécharger automatiquement les bibliothèques requises pour la version sélectionnée, vous pouvez cocher "Utiliser Maven avec Agilitest". Sinon, vous devrez déplacer manuellement la version dans votre répertoire .actionTestScript.

Enfin, lorsque la version ATS des composants installés n'est pas celle de votre projet, Agilitest vous l'indique par des panneaux d'information présents dans l'onglet propriétés et dans le bandeau projet de l'explorateur de projet.

Que dois-je faire ?

Nous vous conseillons de mettre systématiquement à jour votre version de l'éditeur Agilitest et la bibliothèque ATS qu'il utilise.

Il peut arriver que vous refusiez de terminer un court test et que vous mettiez votre rédacteur à jour plus tard.

Je veux réinitialiser ma configuration

Voici comment réinitialiser votre configuration :

1/ Décochez "utiliser Maven" dans les propriétés de votre projet.

2/ Supprimez les deux répertoires libs et drivers (dans votre répertoire utilisateur sous le répertoire .actionTestScript).

3/ Fermer et redémarrer Agilitest

4/ Vérifiez que les bibliothèques sont bien mises à jour au démarrage et téléchargées dans l'onglet configuration, sinon des boutons vous permettront de les télécharger.

Lors de vos tests fonctionnels, vous devrez mettre en place des contrôles qui correspondent au bon fonctionnement de votre application, en vérifiant que les éléments qui doivent être affichés sont corrects. En général, c'est assez simple lorsque le logiciel fonctionne de manière nominale car il suffit de sélectionner les éléments dont vous avez besoin.

Dans certains cas, il est également nécessaire de vérifier que les cas de fonctionnement non nominaux ne se produisent pas. Et il peut être difficile de reproduire ce type de cas de défaillance lorsque le logiciel fonctionne de manière nominale.

Comment tester un comportement non nominal

Nous allons voir une astuce qui n'est pas utilisable dans tous les cas, mais qui peut vous aider dans certaines situations.

Dans notre exemple, la page que nous allons tester doit afficher un fichier pdf. En mode nominal, ce fichier est affiché en utilisant la visionneuse interne de votre navigateur web. Le code utilisé est similaire à celui-ci :

<object data="agilitest.pdf" type="application/pdf">

En mode nominal , vous obtenez le résultat suivant :

Lorsqu'on consulte un fichier pdf produit par une application qui peut être différente d'un cas à l'autre, il peut être très difficile de vérifier que le pdf s'affiche bien : le contenu peut être totalement différent d'une publication à l'autre et parfois on ne sait pas vraiment quoi chercher.

Il devient intéressant de vérifier que le cas de non-affichage du pdf ne se produit pas. Mais voilà : comment le simuler si ma page fonctionne correctement.

L'astuce consiste à aller éditer directement la page dans Chrome pour lui dire d'ouvrir un document pdf qui n'existe pas.

Il suffit de cliquer sur F12 pour afficher le code HTML de la page :

Le code affiché est le suivant :

<div align="middle">
<object data="agilitest.pdf" type="application/pdf">
<iframe src="https://docs.google.com/viewer?url=agilitest.pdf&embedded=true">
</iframe>
</object>
</div>

Il suffit ensuite de modifier le nom du fichier, par exemple en ajoutant une lettre, et d'appuyer sur la touche ENTER : Chrome interprétera le nouveau code et affichera le résultat : Cet affichage correspond à celui que vous obtiendrez lorsque le fichier pdf n'est pas correctement généré et n'est pas disponible.

Il suffit d'effectuer un contrôle graphique sur une partie de cet affichage représentative d'uncas d'erreur:

Passez en mode capture et sélectionnez une partie du message affiché, puis déposez-la dans Agilitest pour créer un contrôle des occurrences.

Veillez à définir que le nombre d'occurrences de l'image doit être égal à zéro, ce qui correspond au résultat nominal.

Dans cet exemple particulier, nous avons utilisé la reconnaissance graphique parce que nous voulons contrôler l'affichage d'un visualisateur de pdf interne à Chrome. Il est possible que pour vos cas particuliers, vous puissiez traiter ce contrôle final uniquement avec des éléments internes, (DOM ou structure de votre application Android ou iOS) affichés dans une jolie popup d'erreur.

L'éditeur Agilitest est très particulier, car il permet de rejouer les tests et de les modifier en même temps, avec la granularité d'une simple action.

Cela vous permet d'aller à l'essentiel lorsqu'il s'agit de modifier un test ou de le maintenir. Ces activités sont nécessaires pour faire vivre votre base de tests, mais il est évident que vous devez passer le moins de temps possible à vous concentrer sur l'essentiel : augmenter la couverture fonctionnelle ou la profondeur de vos tests, faire des tests exploratoires...

Pas à pas

Agilitest vous permet de rejouer les actions indépendamment les unes des autres. Il suffit de cliquer sur le bouton de lecture qui apparaît en haut à droite de chaque action activable lorsque vous la survolez.

Agilitest effectuera alors immédiatement cette action sur le logiciel testé et vous renverra le résultat.

Dans ce cas, l'élément n'a pas pu être localisé et l'action a échoué : il est alors nécessaire de modifier le locator de l'objet s'il existe toujours, ou de modifier le test plus en profondeur.

Ce mode de fonctionnement vous permet d'exécuter votre test pas à pas en sélectionnant successivement les actions les unes après les autres et de vérifier ainsi le déroulement de chaque action.

Il est également très puissant de mettre en place le logiciel testé dans un contexte sur lequel vous savez que vous pourrez poursuivre votre édition de test.

Par exemple : cliquez sur une navigation URL pour revenir au lancement de la page.

Points d'arrêt

La façon la plus simple de modifier une action existante ou d'insérer une action à un endroit donné est de définir un point d'arrêt.

Pour ce faire, il suffit de cliquer sur le petit bouton STOP en haut à gauche de votre action.

Ensuite, vous exécutez votre test en cliquant sur Exécuter dans l'onglet Gestion canal.

Le test s'exécute alors jusqu'au point d'arrêt et s'arrête juste avant de jouer l'action.

Si vous sélectionnez l'exécution en mode réduit dans l'onglet de gestion des canaux, l'éditeur Agilitest sera réduit pour vous permettre de mieux voir ce qui se passe dans votre application, cela peut être utile si vous n'avez qu'un seul écran.

Quel que soit le mode d'exécution choisi, il suffit d 'entrer dans le mode capture pour sélectionner un nouveau composant ou récupérer le locator du composant à l'origine d'un KO.

Vous pourrez alors vérifier que votre action se déroule bien, étape par étape.

Mode d'exécution Java

Le mode pas à pas est un mode spécial dédié à l'édition / modification des tests. ATS a été conçu pour générer du code java afin d'exécuter des tests compilés, ce qui est particulièrement adapté au lancement de tests d'intégration continue, ou à l'exécution de campagnes de tests complètes dans Agilitest. Il est rapide et efficace.

Agilitest permet d'appeler du code javascript sur un composant qui a été capturé.

Cela diffère d'un appel java qui s'apparente davantage à un appel d'indice.

Dans les deux cas, vous devez être informé qu'il sera possible de modifier les éléments du logiciel que vous testez, et donc de vous détacher de l'opération que vous êtes censé contrôler.

Dans certains cas, c 'est très pratique, voire nécessaire: Nous allons voir le cas du curseur.

L'image suivante montre deux curseurs dont la valeur initiale est de 50.

Lorsqu'on manipule un curseur, il est assez complexe de définir une valeur précise uniquement en utilisant les actions de déplacement de la souris, comme le montre l'exemple ci-dessous, les deux curseurs affichent des valeurs différentes pour un même glissement de 100 pixels vers la droite.

Quel est le problème ? Si vous effectuez un test basé sur un déplacement de 100 pixels et que par la suite la valeur du curseur est critique pour le succès de votre test, vous devenez dépendant de l'implémentation du curseur.

Dans ce cas, le javascript est particulièrement adapté, car il vous permettra de définir une valeur directement sur l'élément du curseur en modifiant la valeur de sa variable interne :

valeur=75 ;

‍

Ensuite, les deux curseurs qui ont des tailles différentes permettent de régler la même valeur, quel que soit le mouvement des curseurs, qui sont différents.

Contrôles visuels

Vous pouvez modifier le style et donc la couleur des éléments que vous testez, pour cela il suffit de modifier l'objet style :

style.backgroundColor="vert"

Cela vous permettra d'afficher des contrôles visuels dans les fichiers ATSV ou les rapports XML produits par Agilitest. Cela peut être utile...

Un contrôle complexe intégré à la page

Dans certains cas où vous devez effectuer un contrôle complexe sur votre page, il est tout à fait possible de coder ce contrôle dans un code javascript chargé dans la page, puis d'appeler la fonction javascript dans votre test en récupérant la valeur retournée pour effectuer un contrôle simple.

Ce n'est pas une situation optimale car vous devrez peut-être gérer du code de développement incluant cette fonction et du code de production avec les aléas qu'elle peut provoquer, mais cela peut conduire à des situations complexes à gérer.

Pour cela, il suffit de déclarer une fonction globale dans une balise SCRIPT de votre page :

<SCRIPT>
function checkpage() {
    ....operations...
    if (condition) {
       return true;
    } else {
       return false;
    }
}
</SCRIPT>

Il suffit ensuite de l'appeler depuis votre éditeur Agilitest, en faisant référence à une variable de retour, sur laquelle vous n'aurez qu'à effectuer un contrôle de valeur.

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur l'utilisation des variables :

Une gestion conviviale

Notre approche : pour produire un logiciel qui permette à des personnes non familiarisées avec le développement d'effectuer des tests logiciels automatisés, nous avons beaucoup réfléchi à l'idée de variables et à la manière de les mettre en œuvre dans Agilitest.

Nous avons décidé de les implémenter de manière à ce qu'elles n'aient pas d'impact sur le déroulement des actions effectuées par le testeur. C'est pourquoi il n'y a pas d'action de calcul, d'action de mise à jour, ni d'action de transformation des variables dans Agilitest. Toutes ces opérations sont gérées dans un onglet séparé dédié à la gestion des variables.

Ce comportement permet de réserver la partie éditée du script aux actions sur les composants des applications testées et aux vérifications qui sont faites, et facilite la compréhension des tests.

Pour simplifier les opérations et éviter les erreurs, nous avons défini deux origines de variables :

-les variables de couleur orange qui proviennent de l'interface utilisateur et des éléments de l'application testée, et qui ne sont pas modifiables.

-les variables de couleur violette qui sont déclarées par l'utilisateur ou créées à partir de variables orange non éditables, elles peuvent être éditées et modifiées

Ces deux types de variables peuvent être utilisés pour déclarer de nouvelles variables violettes.

L'ensemble des variables d'un test est donc un assemblage d'arbres de dépendances de variables, Agilitest et ATS mettront automatiquement à jour les variables dépendantes d'autres variables lorsqu'elles seront modifiées.

Ainsi, l'utilisateur ne doit se préoccuper que de récupérer des valeurs sur les éléments des pages ou des écrans testés et de créer des variables dépendantes, et il sait que, de toute façon, les valeurs de l'ensemble des variables dépendantes qu'il a déclarées seront toujours à jour avec le contexte actuel du test effectué.

Ce mécanisme permet beaucoup de flexibilité et de facilité de traitement pour les personnes qui ne sont pas habituées au développement informatique.

Comment créer une variable ?

Il y a plusieurs façons de créer des variables dans Agilitest :

Variable d'environnement

Les variables d'environnement sont déclarées dans les exécutions de votre projet, dans l'onglet"Paramètres d'exécution".

Il suffit de sélectionner une exécution, puis vous pouvez ajouter un nouveau paramètre et modifier sa valeur.

NB : Ces variables sont nécessairement déclarées comme chaines de caractères et ne peuvent pas utiliser des fonctions de modifications qui sont accessibles pour les autres variables.

Pour les utiliser dans vos scripts, utilisez la fonction $env(nom_du_paramètre), par exemple, dans le cas ci-dessus, $env (browser) affichera "chrome".

Variable de script modifiable

Ces variables sont créées dans l'onglet "Variables du script courant" en cliquant sur le menu et en sélectionnant "Créer une variable".

Vous allez créer une variable de couleur violette, modifiable. Vous pouvez ensuite lui donner un nom et une valeur.

Dès que votre variable a une valeur, celle-ci apparaît à droite de son nom. Cela permet à tout moment de vérifier les valeurs des variables du script en cours.

Si la variable n'est pas déclarée correctement et qu'Agilitest ne peut pas lui attribuer une valeur, il affiche un message d'erreur en plus du nom de la variable.

Pour définir la valeur de la variable, vous pouvez utiliser le menu"Insérer une valeur spéciale" à droite du champ de saisie, qui vous donne accès à toutes les catégories de variables pouvant être utilisées dans Agilitest.

Ces fonctions sont accessibles pour définir toutes les variables éditables dont vous aurez besoin, elles peuvent être concaténées pour générer une valeur plus complexe.

Voici les principales fonctions pour y accéder :

$env(paramètre): Renvoie la valeur d'un paramètre d'exécution défini dans l'exécution courante.

$var(variable): Retourne la valeur d'une variable

$param(index_param): Dans un indice, renvoie la valeur d'une variable passée en paramètre en donnant son indice.

‍

• Random chaîne de caractère:

Renvoie un chaîne de caractère aléatoire indiquant le nombre de caractères souhaité et sa casse. La fonction s'utilise comme suit :

$rndstring(10) : génère un chaîne de caractère de 10 caractères aléatoires

$rndstring(15, low): génère un chaîne de caractère de 15 caractères en minuscules

$rndstring(8,upp): génère une majuscule chaîne de caractère de 8 caractères

‍

• Id. unique:

Renvoie un identifiant dans le format Universal Unique Identifier, il est utilisé comme ceci :

$uuid: génère un UUID, exemple : 110e8400-e29b-11d4-a716-446655440000

‍

• Maintenant:

Renvoie un chaîne de caractère indiquant l'heure actuelle de l'ordinateur qui rejoue le test (ou le serveur d'intégration continue), il est utilisé comme ceci :

$now: heure du serveur, par exemple : 17:38:11

‍

• Aujourd'hui:

Renvoie un chaîne de caractère indiquant le jour actuel de la station qui rejoue le test (ou le serveur d'intégration continue), il est utilisé comme ceci :

$today: jour du serveur, par exemple : 08/30/2019

‍

• Identifiant du projet:‍

‍Retourne un chaîne de caractère qui identifie le projet contenant le fichier ats, il est utilisé comme ceci :

$pgav: com.functional.Test(0.0.1)

‍

Variables de script non modifiables

Ces variables sont générées à partir d'éléments des applications testées, en utilisant l'action "Propriété".

Cette action prend en entrée un élément de l'interface utilisateur qui devra être capturé, ainsi que le nom de l'attribut de cet élément qui nous intéresse.

Ces variables sont de couleur orange et ne peuvent être modifiées.

Utilisation avancée des variables

Agilitest vous permet de transformer une variable de 5 façons différentes pour faciliter les calculs.

• Chaines de caractères
• Expressions régulières
• Date
• Temps
• Numérique

Chaines de caractères

Par défaut, toutes les variables sont des chaines de caractères.

Une variable peut être transformée à la création en cliquant sur le bouton correspondant.

La transformation d'une chaîne de caractère fait apparaître une page selon le type qui permettra de la gérer. Si vous cliquez sur le bouton "Annuler", votre variable redevient un chaîne de caractère .

Nous allons prendre deux variables qui serviront d'exemple.

date : 8/9/2019
heure : 11:34:33

Vous pouvez concaténer des variables au format chaîne de caractère entre elles et avec du texte.

Par exemple, si vous créez une variable $day, et que vous lui donnez la valeur $var (date)_$var (heure), sa valeur littérale sera 8/9/2019_11 : 34 : 33

Transformation d'expressions régulières

Les expressions régulières sont utilisées pour diviser les chaines de caractères afin de générer des variables correspondant à des sous-groupes de caractères.

Le menu de gestion des expressions régulières vous demande un modèle qui doit correspondre à votre valeur originale.

Ce modèle comporte des parenthèses qui définissent les sous-groupes et sont utilisées pour déterminer quelle sera la valeur de la variable. En sélectionnant le groupe 1, la variable aura la valeur qui correspond au modèle défini dans la première parenthèse.

Transformation en date

Il est possible d'effectuer des calculs de date pour obtenir une date plus ou moins tardive, dans un jour, un mois, etc.

À partir de la valeur saisie, des sélecteurs permettent d'ajouter ou de soustraire des jours, des mois ou des années.

Le format d'origine pris en charge peut être m/j/aa ou aaaa-mm-jj.

La date obtenue peut ensuite être utilisée dans des variables regex pour récupérer le jour, le mois ou l'année.

Transformation en temps

Il fonctionne de la même manière que la transformation d'une variable en date, dans ce cas les sélecteurs vous permettent d'ajouter ou de supprimer des heures, des minutes ou des secondes à un moment donné.

Le format de la variable d'entrée est hh:mm:ss

Transformation en numérique

Les variables transformées en numérique sont utilisées pour manipuler des entiers ou des décimales au format nn.nnnnnn.

Le format d'entrée peut être un nombre décimal respectant ce format, mais aussi un nombre décimal dont le séparateur sera une virgule.

Il est possible d'utiliser des opérateurs standard pour effectuer des calculs :

• +: addition
• - : soustraction
• *: multiplication
• / : division  

Les fonctions mathématiques les plus courantes sont implémentées : sin, cos, tan, puissance, ln, etc.

Pour des cas très spécifiques où vous auriez des opérations particulières à effectuer, vous pouvez appeler du code java en passant certaines valeurs en paramètre et en récupérant ensuite une variable sur laquelle vous pouvez mettre un contrôle.

Comment contrôler les données du tableau

Le titre est un peu complexe mais correspond à un cas que l'on rencontre souvent dans les tests logiciels automatisés :

Vous voulez contrôler les valeurs d'une cellule qui se trouve sur la même ligne qu'une autre cellule que vous connaissez.

Par exemple, dans le tableau ci-dessus, nous voulons contrôler que Chromium est bien disponible sur Android, c'est-à-dire qu'il y a Oui dans la colonne Android de la ligne Chromium.

Agilitest vous permet de le faire simplement par une astuce d'agrégation de texte: si vous sélectionnez la ligne TR correspondante de la table Chromium, vous pourrez récupérer un attribut TEXT qui est une concaténation de toutes les valeurs des cellules de la ligne.

La valeur textuelle de la ligne TR contenant le chrome est la suivante :

Chrome Oui Oui Oui Oui Oui Oui Non Non

La valeur que vous voulez contrôler est le 5ème Oui.

Pour récupérer la ligne qui correspond à Chromium sans supposer aucune des valeurs suivantes, votre locator ressemblera à ceci :

(?i)Chrome\s(.*)\s(.*)\s(.*)\s(.*)\s(.*)\s(.*)\s(.*)\s(.*)

(?i) indique que le contrôle doit être insensible à la casse.

\s correspond à un espace

(.*) correspond à tout type de texte, en l'insérant avec des \, il correspond au texte avant un espace, le comportement "gourmand" des expressions régulières va alors essayer de correspondre à autant de caractères que possible.

Créez ensuite une variable qui récupérera la valeur spécifique de la colonne Android.

Utilisez l'expression régulière suivante :

(?i)(.*)\s(. *)\s(. *)\s(. *)\s(.*)\s(.*)\s(.*)\s(.*)\s(.*)

Le groupe correspondant est le 6ème

Il suffit alors de faire un contrôle de valeur :

Plusieurs commentaires sur ce tour :

Premièrement, vous devez maîtriser les données de vos tests, il peut donc être dangereux d'utiliser cette technique lorsque vous ne savez pas où se trouve la ligne Chrome dans le tableau. Vous pouvez vous retrouver avec un test un peu laxiste qui ne sait pas vraiment où se trouvent les données.

Adaptez donc cette technique au cas par cas, par exemple si vos données de test ne sont pas encore fixées et que vous ne voulez pas modifier votre test trop souvent.

Il est également possible de l'utiliser si vous faites du Data Driven Testing, les contrôles mis en place s'adapteront aux données que vous avez définies dans un fichier CSV. Dans ce cas, des précautions sont à prendre : par exemple "Internet Explorer" contient un espace qui sera utilisé par l'expression régulière et décalera toutes les données que vous voudrez contrôler.

Pour terminer avec cet exemple, vous pouvez utiliser une action "Vérifier les valeurs" pour contrôler toute la ligne de Chromium en une seule fois. Vous contrôlez d'un coup mais vous ne saurez pas en cas d'échec quelle valeur n'était pas conforme.

Le but des tests logiciels, outre le respect des procédures d'exécution, est de pouvoir contrôler que le logiciel respecte le comportement attendu.

Nous allons voir quelles sont les fonctions d'Agilitest qui permettent d'effectuer des contrôles ou des assertions dans vos tests logiciels.

La fonction de contrôle

Tout passe par la fonction "Vérification", qui se décline en trois sous-fonctions :

• Vérifier les propriétés
• Vérifier les occurrences
• Vérifier les valeurs

"Vérifier les propriétés" et "Vérifier les valeurs" fonctionneront de la même manière. La seule différence est que dans un cas nous vérifierons les propriétés d'un élément de l'interface utilisateur et dans l'autre les valeurs d'une variable.

L'occurrence du contrôle permettra de contrôler le nombre d'éléments comptés dans la page affichée du logiciel testé.

Vérifier les propriétés

Cette fonction prend en entrée un élément d'interface qui devra être capturé.

Dans l'exemple ci-dessus, nous sélectionnons un SPAN avec un "id" égal à "cwos".

Nous vérifions ensuite sa propriété "text" qui doit être égale à 4.

La fonction de vérification effectuera la comparaison en considérant les deux paramètres comme chaines de caractères; et accepte les expressions régulières.

Vérifier les valeurs

Cette fonction prend en entrée une variable qui peut être modifiable ou non.

L'opération est alors identique à l'action "Vérifier les propriétés".

Vérifier les occurrences

La vérification de l'occurrence contrôle le nombre d'éléments trouvés sur la page actuelle en utilisant un Agilitest locator.

En effet, dans certains cas, il peut être utile de définir des localisateurs qui peuvent correspondre à plusieurs éléments. Cela permet par exemple de contrôler le nombre de lignes ou de colonnes d'un tableau.

L'action "Vérifier les occurrences" est également très utile pour ajouter plus de robustesse à vos tests.

Occurrence des contrôles et reconnaissance graphique

La vérification des occurrences fonctionne également avec les éléments graphiques.

Vous pourrez vérifier qu'une image est présente un certain nombre de fois dans la page affichée.

Ceci diffère d'un contrôle basé sur la structure du logiciel, par exemple le DOM, pour lequel même les éléments non affichés seront comptés.

Vous pouvez également combiner la vérification des occurrences et la reconnaissance graphique pour déterminer quand vous pourrez poursuivre votre test. Dans l'exemple ci-dessous, nous attendons la fin d'un traitement en vérifiant sa "barre de progression", et en la comparant à celle qui sera affichée à la fin du traitement.

Agilitest est connu pour sa large couverture de diverses technologies récentes dans le domaine du développement logiciel, et vous permet généralement d'automatiser à peu près tout ce qui peut l'être en quelques clics et graphiquement.

Dans certains cas, cependant, il est utile d'appeler un code externe pour effectuer une opération spécifique à l'environnement du client.

Nous allons voir dans cet article comment Agilitest peut appeler un morceau de code java, en passant des variables d'entrée et en récupérant des paramètres de sortie.

Bien évidemment, nous recommandons toutes les précautions d'usage dans l'utilisation du code externe java, car s'il permet de tout faire, il peut aussi avoir un impact non désiré sur le SUT (System Under Test).

En termes de portabilité, le code .ats que produit Agilitest est transformé en java pour être exécuté. Vous pouvez donc considérer que le code java que vous écrirez sera portable sur les différentes plateformes supportées par ATS.

Quoi, écrire du code !

Allons-y !

Pour commencer, vous allez générer le stub de votre code java dans Agilitest en faisant ce qui suit :

• Dans l'explorateur Agilitest, sélectionnez le répertoire java dans src / main au même niveau que vos fichiers .ats .
• Faites un clic droit et sélectionnez : Nouveau script java.
• L'éditeur ouvre une popup pour demander le nom du script, entrez le nom de votre script et cliquez sur OK.
• L'éditeur ouvre alors une fenêtre d'édition de code java et, après les déclarations nécessaires et utiles, affiche la fonction qui sera appelée : testMain().

public class test extends ActionTestScript{
public void testMain() { }
}

Paramètres

Il est possible de passer des paramètres par valeur à votre script java.

Pour ce faire, vous devez cliquer sur "appeler le script" ou sur le petit crayon qui apparaît lorsque vous survolez l'action, puis cliquez sur "ajouter un paramètre".

Ensuite, vous pouvez entrer les valeurs que vous voulez passer à votre script, et vous pouvez utiliser toutes les possibilités offertes par l'éditeur Agilitest pour cela : utilisation de variables, valeurs en "dur", itérations sur un fichier .csv.

Pour les récupérer du côté du code java, vous disposez de la fonction getParameter(int), qui prend un entier correspondant à l'indice de la variable dans l'appel de l'indice : getParameter(0) retournera la première valeur passée dans les paramètres.

chaîne de caractère param1 = getParameter(0).toString() ;
int param2 = getParameter(1).toInt() ;
double param3 = getParameter(2).toDouble() ;
boolean param4 = getParameter(3).toBoolean() ;

Récupération des résultats

Les résultats sont récupérés de manière symétrique à l'appel.

Elle nécessite la déclaration de variables dans l'éditeur Agilitest, qui seront de type non modifiable (par l'utilisateur).

Pour déclarer des variables de retour, procédez comme suit :

• Déclarez une nouvelle variable dans le menu de gestion des variables dans la partie gauche de l'éditeur.
• Le type sera modifiable par défaut (violet).
• Nommez cette variable
• Déposez-le directement dans l'action d'appel de l'indice
• Agilitest va changer le type de la variable pour la rendre non modifiable par l'utilisateur (orange) et l'indiquer comme valeur de retour de l'appel java.
• Par la suite, vous pouvez utiliser cette variable dans votre script

Pour définir une valeur de retour du côté Java, vous disposez de la fonction returnValues() qui prend toutes les valeurs que vous souhaitez renvoyer :

returnValues("value1", "retvalue2", param1) ;

Évidemment, le nombre de valeurs retournées doit correspondre au nombre de variables déclarées du côté de l'éditeur Agilitest.

Exécution du code

Si votre test comprend un script Java, il sera nécessaire de le compiler avant d'exécuter le test. Lors de cette compilation, vos éventuelles erreurs de syntaxe seront mises en évidence. Vous pouvez en savoir plus sur la compilation des tests et la configuration des exécutions.

Une fois votre projet compilé, vous pourrez exécuter votre test, et les actions java comme s'il s'agissait des actions standard d'Agilitest : pas à pas (action Agilitest par action Agilitest) et mode d'exécution identique, chaque action java s'exécutant en une seule fois.

Si votre code java est un peu complexe, et que vous voulez le déboguer, le pas à pas sera possible à condition d'avoir assigné un port de débogage Java dans agilitest et d'avoir un IDE de type eclipse ou intelliJ.

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur les expressions régulières :

Les expressions régulières sont très puissantes pour effectuer des opérations sur les données, extraire des sous-ensembles ou reconnaître des modèles.

Nous autorisons leur utilisation à plusieurs endroits dans Agilitest :

Reconnaissance des composants

En mode Capture, lorsque vous avez sélectionné un composant en appuyant sur la touche CTRL, vous pouvez ensuite cliquer sur l'attribut qui vous intéresse pour en sélectionner la valeur.

Dans le cas présenté ci-dessus, nous n'avons qu'un seul attribut cd_frame_id_ dont la valeur va éventuellement changer dans le temps puisqu'il s'agit d'un UUID.

We can allow Agilitest to recognize it simply by clicking on the "Regular Expression" checkbox and entering the following regular expression in the property value: [0-9a-fA-F]{32}This regular expression indicates that we are going to look for a 32-character string, consisting only of hexadecimal characters.

‍

Ensuite, une demande de statistiques permet de reconnaître l'élément de manière unique dans la page :

Grâce à l'expression régulière, la valeur de l'uuid peut être modifiée, mais tant qu'elle reste un uuid, Agilitest la reconnaîtra.

Cette astuce permet de reconnaître des éléments dont les valeurs d'attributs sont très volatiles, mais qui conservent une structure constante dans le temps : un préfixe ou un suffixe identique, un numéro incrémenté, etc.

Vérification

Il est possible d'utiliser des expressions régulières dans le cadre de la vérification des propriétés des objets ou des valeurs des variables.

Dans le cas ci-dessous, nous utilisons la même expression régulière que précédemment pour vérifier que le format de la propriété cd_frame_id_ est bien celui d'un uuid. Évidemment, nous utilisons un autre moyen d'identification pour trouver l'élément (ici id = examples-iframe).

‍

Manipulations de variables

Enfin, il est possible d'utiliser les expressions régulières pour effectuer des opérations sur les variables, dans le but de récupérer certaines sous-parties de celles-ci. On utilise la notion de parenthèse capturante, associée à un numéro de groupe : l'expression régulière complète est décomposée en sous-expressions entourées de parenthèses, il est alors possible de récupérer la partie de la variable qui nous intéresse par son numéro de groupe correspondant au numéro des parenthèses dans l'expression régulière globale. Dans l'exemple ci-dessous, nous avons récupéré un texte complet qui comprend un prix que nous souhaitons vérifier.

En utilisant l'expression régulière suivante :

(\d),(\d)\N- €(.*)

On peut récupérer successivement :

• Le prix en euros correspondant au groupe 1
• Les centimes après la virgule correspondant au groupe 2
• Le texte supplémentaire correspondant au groupe 3

‍

Enfin, quelle est l'utilité des expressions régulières ?

Vous l'aurez compris : l'utilisation des expressions régulières va vous permettre de cibler chirurgicalement les différents éléments de vos tests : composants, variables, valeurs et d'ajouter beaucoup de robustesse lors de leur exécution. Pour les personnes qui ne les connaissent pas, passé les premières erreurs et la surprise de la découverte, cette technologie est en fait assez simple à utiliser et permet de faire beaucoup de choses sans écrire une seule ligne de code.

Comment fonctionne la reconnaissance des zones graphiques

La reconnaissance des zones graphiques est utilisée dans Agilitest pour permettre :

• pour effectuer des actions de type clic, saisie de texte, etc. sur les zones reconnues.
• d'effectuer des contrôles de reconnaissance graphique des éléments

Voici comment cela fonctionne :

A tout moment lorsque vous êtes en mode "capture", vous pouvez identifier une zone rectangulaire de l'application testée par glisser-déposer.

La sélection d'un locator

Agilitest affiche alors l'image que vous avez sélectionnée et vous permet de la copier, de la sauvegarder, ou de passer directement à la génération d'un locator en l'utilisant, en activant l'affichage de l'arbre des éléments.

Lorsque vous cliquez sur "Element Tree", Agilitest affichera la structure du logiciel ou DOM jusqu'au plus petit élément qui contient complètement l'image sélectionnée. Cette opération vous permettra d'assurer une identification unique de votre image qui pourrait être imprimée à plusieurs endroits de votre logiciel.

En effet, sans sélectionner un locator, vous pouvez vous retrouver avec une image présente à plusieurs endroits, il suffit d'utiliser l'outil loupe pour s'en rendre compte :

Pour résoudre ce problème, il suffit de sélectionner les éléments parents et leurs attributs pour générer un locator supplémentaire et de déposer le tout dans une nouvelle action de l'éditeur Agilitest.

Si pendant cette phase de sélection du site locator vous cliquez sur le bouton "Statistiques", Agilitest masquera temporairement la grille de capture afin que vous puissiez reconnaître le composant graphique dans la page.

Juste après le dépôt dans l'éditeur, la génération d'une nouvelle action est effectuée et affichée. Elle contient un lien vers une image qui est sauvegardée dans le répertoire src/assets/resources/images.

Vous pouvez visualiser toutes les images qui ont été utilisées dans votre projet en sélectionnant le menu "Show resources images" de l'explorateur de projet :

Le menu de recherche d'image que vous obtenez en cliquant sur l'image dans l'éditeur vous permet d'ajouter les informations suivantes :

• Utilisation d'un locator pas unique pour identifier les occurrences, puis sélection par un index de l'image de manière unique.
• Vous pouvez agir sur la tolérance de reconnaissance graphique et sur l'algorithme utilisé. Pour le moment, seul l'algorithme ATS est proposé et nous vous conseillons de conserver la tolérance par défaut (0,5%).

Affirmations graphiques

Les assertions d'occurrence vous permettront d'ajouter des contrôles sur la présence d'éléments graphiques dans vos applications, de les compter, de générer des temporisations d'attente, etc.

Pour les réaliser, il suffit de déposer l'élément graphique dans une action de type "Contrôle d'occurrence".

Cependant, nous devons porter une attention particulière à ce contrôle des occurrences : Agilitest va contrôler les images qui sont effectivement affichées sur la page (contrairement à une approche DOM qui peut potentiellement tracer les objets non affichés).

Dans ce cas, il faut s'assurer que la fenêtre est correctement dimensionnée et affichée pour permettre une reconnaissance complète des éléments.

Pourquoi Agilitest a besoin de pilotes Web

Agilitest est une solution logicielle installée sur votre ordinateur et régulièrement mise à jour au lancement.

L'objectif est de mettre à disposition le plus rapidement possible de nouvelles fonctionnalités pour nos clients, de corriger les bugs présent dans la solution, mais aussi de s'adapter aux évolutions des navigateurs que nous supportons.

Dans les faits, sans configuration supplémentaire, Agilitest supporte actuellement 5 navigateurs : Chrome, Firefox, NewEdge, Opera et Internet Explorer en version 11.

Notre philosophie est de fournir un support le plus rapidement possible aux dernières versions des navigateurs, et c'est pourquoi nous utilisons les pilotes web pour communiquer avec les navigateurs : nous pouvons fournir un support très rapide dès que les pilotes Selenium sur lesquels nous nous appuyons sont mis à jour sur ces dernières versions.

Par conséquent, la mise à jour d'Agilitest apportera avec elle la dernière version du pilote et pilotera la dernière version du navigateur, et généralement vous n'avez rien à faire car :

• Si vous mettez à jour votre navigateur, cela devrait se faire sans impact sur l'opération.
• Si vous ne le mettez pas à jour, eh bien, il est souvent possible que le dernier pilote assure une rétrocompatibilité avec les versions précédentes des navigateurs, et dans la plupart des cas, cela se passe bien.

La mise à jour de Chrome 74

Sauf que cela ne s'est pas passé comme prévu pour Chrome 74 : La mise à jour de fin avril 2019 et chromedriver Selenium a apporté une rupture de compatibilité avec Chrome 73. Et depuis cette date, cela arrive en quelque sorte avec les nouvelles versions.

Pour permettre à nos clients de mettre à jour leur version de d'une version de Chrome à une autre, nous avons rendu possible le déploiement de configurations alternatives n'annonçant pas le support officiel.

Par exemple, actuellement, Agilitest peut piloter Chromium et une extension de celui-ci, JXBrowser, un navigateur intégrable dans un client lourd java.

Comment procéder

L'ajout de nouvelles versions de navigateur à Agilitest nécessite la configuration de l'éditeur dans le fichier .atsProperties.

Pour configurer un nouveau navigateur, insérez les lignes suivantes dans votre fichier .atsProperties :

<browser>
<name>chromium</name>
<driver>chromiumdriver</driver>
<path>D:\tools\chromium\chrome.exe</path>
</browser>

Le badge nominatif vous permet de nommer le navigateur tel qu'il sera imprimé dans Agilitest. Un certain nombre de noms sont réservés car nous nous adaptons aux spécificités de chaque navigateur : chrome, firefox, etc. Vous ne pourrez donc modifier le driver et le chemin de l'exécutable que pour un navigateur déjà connu d'Agilitest.

La balise driver indique à Agilitest le nom du driver .exe à charger (dans le répertoire $ user /.actiontestscript/drivers/directory).

Voici les liens des pilotes pour Chrome, Firefox, IE, et Edge

‍

La balise path indique le chemin de l'exécutable du navigateur.

Par exemple, si vous voulez utiliser Firefox 60 ESR, la procédure est la suivante :

• Téléchargez et installez Firefox 60 ESR dans un répertoire différent de celui de votre installation de Firefox.
• Complétez les lignes suivantes dans votre fichier .atsProperties :

<browser>
<name>firefox</name>
<path>D:\tools\firefox60ESR\firefox.exe</path>
</browser>

Dans le cas de firefox, le pilote utilisé devrait être compatible avec la dernière version et la version ESR, il n'est donc pas nécessaire d'ajouter un changement de pilote.

Pour spécifier le chemin de MSEdge, vous pouvez utiliser les lignes suivantes :

<browser>
<name>msedge</name>
<path>C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe</path>
</browser>

Qu'est-ce que JxBrowser ?

JxBrowser est une couche d'application pour l'intégration de pages web modernes, contenant HTML, CSS et Javascript, dans des applications Java. Il permet de construire l'interface graphique de votre application multi-bureau en utilisant n'importe quelle boîte à outils UI HTML5 populaire. Vous pouvez également utiliser les boîtes à outils HTML5 récentes pour produire des applications java fonctionnant sur plusieurs plateformes. JxBrowser est basé sur le projet open-source Chromium qui comprend le code source et les bibliothèques écrites par les développeurs de la communauté Chromium.

JxBrowser est une bibliothèque puissante qui permet aux développeurs d'intégrer un composant de navigateur Web dans leurs applications Java. Avec JxBrowser, les développeurs peuvent facilement afficher et interagir avec le contenu Web dans leurs applications Java, ce qui facilite la création d'interfaces utilisateur riches et modernes. La bibliothèque est basée sur le projet Chromium, qui fournit le moteur de rendu sous-jacent et l'ensemble des fonctionnalités de JxBrowser. Cela permet aux développeurs de tirer parti des dernières technologies Web, telles que HTML5, CSS3 et JavaScript, sans avoir à se soucier des problèmes de compatibilité entre navigateurs.

L'une des principales caractéristiques de JxBrowser est sa capacité à interagir avec les pages Web en utilisant le langage de programmation Java. Les développeurs peuvent ainsi appeler des fonctions JavaScript et accéder au Document Object Model (DOM) des pages Web directement à partir de leur code Java. Cela peut être utile pour automatiser les interactions avec les pages Web ou pour créer des interfaces utilisateur personnalisées à partir de pages Web existantes.

En plus de ses capacités de rendu Web, JxBrowser offre également un certain nombre d'autres fonctions utiles, telles que la prise en charge des paramètres de proxy, des cookies et des extensions de navigateur. Cela permet aux développeurs de personnaliser le comportement du navigateur embarqué pour répondre aux besoins de leur application spécifique.

Globalement, JxBrowser est un excellent choix pour les développeurs qui souhaitent ajouter une fonctionnalité de navigation Web à leurs applications Java. Grâce à ses puissantes fonctionnalités et à la prise en charge des technologies Web modernes, JxBrowser peut aider les développeurs à créer des interfaces utilisateur attrayantes et interactives qui fonctionnent sur plusieurs plates-formes.

‍

Comment configurer JXBrowser ?

La configuration de JXBrowser nécessite d'ajouter une nouvelle paire pilote-navigateur à votre fichier de configuration Agilitest .atsProperties. Ce fichier se trouve par défaut dans le répertoire suivant : votre répertoire utilisateur, suivi de .actiontestscript).

You must add a <browser> section as follows:

<browser>
<name>jx</name>
<driver>jxbrowser</driver>
<path>C:\Program\path_to_jxbrowser_based_application\app.exe</path>
</browser>

1. ‍<name> is the name you want to print in Agilitest
2. <driver> : Download the latest Selenium driver for Chromium integrated with JXBRowser, available at:

https://sites.google.com/a/chromium.org/chromedriver/

3. Dézippez le fichier du pilote et copiez le fichier "chromedriver.exe" dans le répertoire d'installation des pilotes Agilitest (par défaut : votre répertoire utilisateur, suivi de .actiontestscript/drivers).

4. Le fichier "chromedriver.exe" doit être renommé par le nom du pilote que vous avez donné dans votre fichier de configuration (dans ce cas, jxbrowser.exe, mais vous pouvez donner le nom que vous voulez tant que cela n'a pas d'impact sur le pilote Chrome et que le fichier .exe correspond à ce qui est configuré dans le fichier .atsProperties).

5. <path>: path to the executable that launches your JXBrowser application

6. La configuration de JXBrowser doit permettre le débogage à distance sur le port 9222.(https://jxbrowser.support.teamdev.com/support/solutions/articles/9000013082-remote-debugging-port)

Différents modes de lancement des applications

Agilitest est une solution multicanal qui vous permet de vous connecter à plusieurs canaux simultanément pour différents types d'applications :

• Canaux Web: Chrome, Firefox, IE, Edge et Opera : en ouvrant un canal sur l'un des navigateurs, puis en effectuant une action de navigation sur une URL.
• Canaux de bureau: Tous les types d'applications compilées pour Windows. Il suffit de sélectionner le fichier exécutable directement dans l'action d'ouverture du site canal (.EXE).
• Chaînes Android: Toutes les applications fonctionnant sur les appareils Android, y compris celles proposées par le système d'exploitation. Dans ce cas, la sélection de l'application passe par une connexion au terminal via "ATS Mobile Station ", qui permet ensuite d'accéder à la liste de toutes les applications installées.
• Les canaux SOAP ou JSON web service : Le web service est sélectionné à l'ouverture du canal , et la navigation permet d'appeler des services spécifiques.

Ma demande ne correspond à aucun de ces cas !

Pour chacune des situations décrites ci-dessus, c 'est Agilitest qui lance l'application testée car c'est son fonctionnement nominal.

Dans certains cas, il n'est pas possible de faire lancer l'application à tester par Agilitest, cela peut se produire par exemple dans les cas suivants :

• Le lancement d'une application avec un fichier .bat initialise les variables d'environnement avant de lancer le .exe. Dans ce cas, il n'est pas possible de lancer directement le .exe. (en fait, vous pouvez utiliser un appel java d'Agilitest pour le faire).
• Lancement de l'application au démarrage de Windows par un service. Cependant, l'application doit disposer d'une fenêtre graphique sur laquelle elle peut agir.
• Utilisation d'une application Windows spécifique pour effectuer certaines opérations dans le cadre d'un test général de bout en bout (par exemple : Explorer.exe).

La solution

Pour utiliser un processus existant comme canal test Agilitest l'astuce consiste à l'identifier parmi les processus en cours d'exécution sur la machine de test. Voici comment procéder :

• Créez une action d'ouverture canal
• Spécifiez le nom du processus auquel vous souhaitez vous accrocher en commençant par process://.

L'utilisation d'expressions régulières est possible pour spécifier le nom de l'application concernée, par exemple :

process://.*notepad\+\+\.exe

Pourquoi sélectionner des fichiers à partir d'un navigateur ?

Lorsque l'on réalise des scénarios d'affaires impliquant des solutions web, il y a un cas qui revient fréquemment : les interactions avec le système d'exploitation, et en particulier la sélection des fichiers pour les télécharger sur le serveur web ( nous parlons d'upload).

Cette fonctionnalité est en effet mise en œuvre par tous les outils gérant des données métier : ERP, GED, PLM, CRM ...

La fonction de téléchargement est implémentée nativement dans tous les navigateurs car ils doivent respecter la norme HTTP qui spécifie comment ce transfert de fichiers s'effectue.

Tous les navigateurs ont donc implémenté un menu de sélection de fichiers sur l'ordinateur ou sur un accès réseau, et le transmettent ensuite au serveur. Cela implique généralement l'utilisation d'une fenêtre modale de sélection de fichiers dont l'implémentation dépend de l'environnement de bureau, mais chaque navigateur peut avoir sa propre implémentation.

Problèmes causés par l'automatisation des tests

Cela entraîne deux types de problèmes lors de l'automatisation de cette procédure dans un test

• Problème 1: Le logiciel de test doit être capable de s'interfacer avec la partie "bureau" du navigateur. Dans ce cas, s'appuyer sur la page HTML et le DOM n'est pas suffisant, il faut soit récupérer et reconnaître la structure interne des composants et contrôles des navigateurs, soit utiliser la reconnaissance graphique...
• Problème 2: La "sélection de fichiers" peut varier fortement d'un navigateur à l'autre, ce qui nécessite des adaptations en fonction du navigateur utilisé.

Solution au problème 1 : Agilitest est une solution multicanal

Agilitest est une solution de test intégrée qui supporte l'utilisation de différentes technologies applicatives (web, desktop, ...) au sein d'un même test. Nous utiliserons un basculement DOM-desktop.

Le problème 1 est facilement traité par Agilitest et voici la solution :

• Ouvrez un canal sur votre application et exécutez votre test jusqu'à la partie téléchargement.
• Lorsque la fenêtre de sélection du fichier s'ouvre, il suffit d'appuyer sur la touche "ALT" de votre clavier pour passer du mode de reconnaissance des composants du DOM au mode de reconnaissance des composants du bureau. Là, vous pourrez naviguer dans votre fenêtre de sélection du fichier.
• A la fin de la sélection de votre fichier, vous pouvez fermer la fenêtre modale et utiliser la touche "ALT" pour revenir à la partie web avec un DOM.

Astuce : Pour plus de robustesse, nous vous conseillons de placer un fichier dans une arborescence facilement accessible de votre système de fichiers et que vous pouvez reproduire partout, par exemple en "accès rapide" sous Windows Explorer.

Solution au problème 2 : Agilitest sait comment gérer le comportement spécifique des navigateurs.

Le problème 2 est géré avec Agilitest à l'aide de sous-scripts établis via un fichier de données (CSV) dans la combinaison suivante data-driven testing fichier de données (CSV) dans la combinaison suivante :

• Appels d'un premier sous-script alimenté par le paramètre "navigateur" en colonne du fichier CSV. Nous récupérons le nom du navigateur pour itérer le lancement du même test sur plusieurs navigateurs.
• Appeler les sous-scripts suivants dont le nom est composé à partir du paramètre "browser" du premier sous-script. Par exemple : script_chrome.ats, script_opera.ats, etc. Nous utilisons le nom du navigateur pour personnaliser le nom du script exécuté.

La solution proposée permet de gérer les différences de comportement des navigateurs. Cependant, nous ne vous recommandons pas de l'utiliser pour les opérations suivantes, qui sont gérées directement par Agilitest pour tous les navigateurs :

• Naviguer vers une URL, vers la page précédente, vers la page suivante, vers la page d'accueil ...
• Fermeture de la fenêtre
• Changement d'onglet

Cela rendrait vos tests non génériques, ce qui n'est pas souhaitable.

Le problème du temps d'attente non constant

Certaines applications sont dépendantes d'éléments externes pour pouvoir poursuivre leur traitement : attente d'une réponse d'un serveur, attente des résultats d'un calcul, attente de l'affichage complet d'une page qui peut dépendre des implémentations des navigateurs, etc.

Cela pose un problème lors de la réalisation des tests fonctionnels : comment gérer correctement cette attente sans provoquer une situation d'échec des tests et sans passer trop de temps à attendre ?

La solution est de ne pas attendre un temps donné pour continuer le test, pour des raisons évidentes : vous ne savez pas combien de temps vous allez devoir attendre. De plus vous allez complètement polluer votre base de données de tests automatisés en saupoudrant ici et là des temps d'attente parfois inutiles, ce qui va considérablement ralentir l'exécution de tous vos tests.

C'est pourquoi vous ne trouverez pas de fonction "attendre" dans Agilitest ...

La solution Agilitest : faire un "contrôle de l'occurrence".

De quoi s'agit-il ?

Un contrôle d'occurrence est une action d'Agilitest qui vérifie qu'un ou plusieurs éléments sont présents ou manquants dans la page ou le logiciel testé.

Cette solution indique à Agilitest que vous voulez contrôler le nombre d'occurrences d'un objet dans votre application.

Il est applicable dans les situations suivantes :

• Nous voulons attendre que la page ait fini de se charger pour poursuivre le traitement. Dans ce cas, nous pouvons effectuer un contrôle d'occurrence sur un élément qui s'affichera en bas de la page à la fin du chargement.
• Nous voulons attendre une modification de la page qui va supprimer les éléments déjà imprimés. Dans ce cas, nous effectuons un contrôle d'occurrence égal à 0 (contrôle d'absence) sur un élément qui doit disparaître avant de poursuivre le test.

Dans les deux cas et tant que les conditions de réussite du contrôle d'occurrence ne sont pas remplies, Agilitest commencera à se considérer "en situation d'échec potentiel" du test, et multiplieradonc les contrôles pour éviter de générer un faux négatif.

Au terme de son contrôle, Agilitest produira une situation d'échec du test, sauf si, entre-temps, les conditions de réussite du contrôle sont réunies, et donc que les éléments que nous attendions sont présents ou ont été retirés.

L'astuce consiste à indiquer à Agilitest le nombre d'essais qu'il devra effectuer pour attendre les conditions de la vérification. Cela se fait en sélectionnant un nombre d'essais maximum qu'il devra effectuer avant de considérer "être en échec" sur cette action.

Chaque action a la possibilité d'attendre et de réessayer plusieurs fois. Cela contribue grandement à la robustesse des tests lorsque vous savez que votre serveur peut être dans une situation où il ne livre pas la page désirée immédiatement.

Le nombre maximum d'essais est limité à 50, mais le temps d'attente entre chaque essai suit une courbe exponentielle : cela permet de vérifier rapidement les conditions de réussite lorsqu'elles sont réunies, mais aussi d'attendre "un certain temps" qu'un traitement long soit effectué.

En utilisant cette solution, nous pourrions même demander d'attendre la fin d'une bande-annonce sur une application Android diffusant de la vidéo ...

Comment attendre encore pour une période déterminée ?

Il y a toujours une solution avec Agilitest, et dans ce cas, elle consiste à utiliser un morceau de code Java, voici comment :

• Dans l'explorateur Agilitest, sélectionnez le répertoire java dans src / main au même niveau que vos fichiers .ats .
• Faites un clic droit et sélectionnez : Créer un script java.
• L'éditeur ouvre une popup pour demander le nom du script, entrez attendre et cliquez sur OK.
• L'éditeur ouvre une fenêtre d'édition de code java, collez le code suivant dans la fonction testMain () :

try {
    final int ms = Integer.parseInt(prm(0, "1000"));
    Thread.sleep(ms);
} catch (Exception e) {}

• Glissez-déposez le script "wait.java" de l'explorateur Agilitest à l'endroit où vous voulez l'appeler dans votre test.

ASTUCE : Si vous voulez pouvoir spécifier le temps d'attente directement à partir de votre script ATS dans Agilitest, vous pouvez déclarer un paramètre passé par valeur au script et ensuite utiliser le code suivant :

try {
        final int ms = getParameter(0).toInt();
        Thread.sleep(ms);
} catch (Exception e) {}

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur le rapport d'exécution :

TestNG est un framework qui a été créé pour exécuter des tests en Java, qui est la base des exécutions ATS produites par Agilitest.

En dehors du mode d'exécution / d'édition spécifique de l'éditeur Agilitest, nous avons développé un mode d'exécution compilé en Java qui est plus rapide et destiné à être utilisé pour un test ou un groupe de tests. dans un projet.

Comme nous allons le voir, les exécutions sont créées dans Agilitest, peuvent être exécutées par Agilitest, mais sont également exportables vers des environnements compatibles TesNG qui pourront rejouer les tests sans nécessiter de configurations complexes.

Pour créer un runtime TesNG dans Agilitest, allez au niveau de la bande du projet dans l'explorateur de projet et cliquez sur la roue dentée.

Gérer l'exécution des projets

Agilitest ouvrira un nouvel onglet avec plusieurs parties :

• Le créateur de projet: Permet de configurer, générer, exécuter, et optionnellement produire les rapports correspondants et les ouvrir. Le fonctionnement du constructeur de projet est abordé à la fin de l'article.
• Ligne de commande: Agilitest vous montre la ligne de commande que vous pouvez utiliser si vous voulez lancer l'exécution de ATS à partir d'une invite de commande sous Windows. Cette commande doit être lancée à la racine du projet ATS . Vous pouvez copier ces éléments dans un fichier .bat ou .ps1 pour lancer toutes les exécutions que vous avez configurées sans passer par Agilitest...
• Exécutions: Il s'agit du menu de configuration des exécutions TestNG dont le fonctionnement est expliqué dans le paragraphe suivant.

Les exécutions

Une exécution correspond à la définition d'un sous-ensemble de tests d'un projet que vous pourrez rejouer en une seule fois.

Pour définir une exécution, cliquez sur le bouton "Ajouter" dans l'onglet exécutions.

Ensuite, entrez le nom de l'exécution à créer, vous la verrez apparaître dans l'onglet exécution.

Un ensemble d'options vous permettra de définir la qualité des rapports produits lors du lancement de l'exécution.

Agilitest générera un fichier .exec correspondant dans le répertoire /src/exec.

Ce fichier est dans le standard TestNG et est un filtre sur tous les tests d'un projet, ainsi que des instructions pour exécuter la campagne de test correspondante.

Vous avez plusieurs options pour définir ce sous-ensemble de tests :

Ajouter des scripts à une exécution

Ajoutez des scripts directement dans l'onglet "Scripts": Déposez les fichiers ATS directement depuis votre explorateur de projet pour les voir sur votre onglet.

Sélectionner des forfaits

Indiquez quels sont les répertoires dans lesquels il faut récupérer les scripts, et ceux qui ne sont pas concernés.

L'onglet "Packages" présente tous les répertoires de votre projet et vous permet pour chaque répertoire de définir si les fichiers ATS qu'il contient doivent être inclus ou exclus de la sélection.

Il n'est pas nécessaire que les fichiers aient été ajoutés au préalable dans l'onglet script.

Sélection transversale par groupes

Les groupes de tests vous permettent de filtrer les tests en fonction des groupes auxquels ils sont associés.

Le menu groupe vous permet de définir de nouveaux groupes et de sélectionner des groupes à ajouter ou à exclure d'une exécution.

Paramètres d'exécution

Les paramètres d'exécution sont des variables que vous allez définir pour une exécution donnée et qui apparaîtront comme des variables d'environnement dans l'ensemble des tests qui sont affectés par cette exécution.

Les variables d'environnement vous permettront de gérer différents environnements d'exécution, qui utiliseront toutefois la même base de test.

Configuration des rapports

En cliquant sur le petit crayon qui apparaît dans l'aperçu des exécutions, vous pouvez sélectionner un certain nombre de paramètres pour gérer le niveau et la qualité des rapports que vous souhaitez produire.

Voici les différentes options qui sont proposées :

Niveau des journaux

Les différents niveaux de journalisation sont les suivants :

• Silencieux
• Erreur
• Info
• Avertissement

Ils sont classés du moins bavard au plus bavard.

Rapport XML

Si vous décidez de produire un rapport XML, il peut être directement converti en pdf par Agilitest.

Rapport visuel

Indique la qualité des rapports vidéo ATSV que vous allez générer. Les différentes options sont :

• Off : pas de génération de rapport
• Taille : optimiser la taille des fichiers ATSV
• Vitesse : optimiser la vitesse de génération des rapports
• Qualité : optimiser la qualité des rapports générés
• Qualité maximale : tout optimiser

Commencer une exécution à Agilitest

Une fois que votre exécution est créée ou sélectionnée, vous pouvez effectuer les opérations suivantes dans le constructeur de projet :

Generate : génère les fichiers java correspondant aux tests ATS sélectionnés.

Compile: compile les fichiers java correspondant aux tests sélectionnés sur ATS (inclut la phase "generate").

Exécuter: Agilitest ouvrira une console et rejouera tous les tests sélectionnés dans l'exécution. (Inclut les phases "générer" et "compiler").

Il y a deux options possibles :

• Ouvrir le rapport TestNG à la fin de l'exécution : ouvre le rapport produit par TestNG.
• Générer le rapport pdf pour chaque test et ouvrir les rapports générés (ainsi que les tests rejoués).

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur la gestion des scripts :

Comment gérer les suites d'exécution

Les suites d'exécution sont très utiles pour définir des critères de sélection des tests qui les différencient les uns des autres, ou pour les regrouper par domaines identiques : fonctionnel, importance et priorité lors du rejeu, typage, environnements d'exécution, etc.

Ces groupes d'exécutions sont indépendants des répertoires dans lesquels les tests sont enregistrés.

Pour définir un groupe, allez dans les exécutions du projet et cliquez sur "Ajouter" dans l'onglet Groupes.

Par la suite, le groupe devient accessible à tous les tests du projet.

Pour affilier un test à un groupe, il suffit d'ouvrir l'onglet "Données d'en-tête du script".

Toutes les informations sur le script sont alors affichées, ainsi que les groupes disponibles pour ce script.

Il suffit de sélectionner le groupe souhaité et d'enregistrer votre script.

Par la suite, ce groupe peut être utilisé pour définir une exécution, et votre test sera rejoué automatiquement lorsque l'exécution sera rejouée.

En plus des tests et contrôles à effectuer, le format ATS permet de définir un ensemble de méta-données très utiles pour caractériser l'ensemble de vos tests.

Pour y accéder, cliquez sur l'icône "Page" en haut à droite de la fenêtre d'édition de votre script.

Vous verrez alors apparaître un sous-menu dont l'activation modifiera l'affichage de votre éditeur en fonction des informations à afficher :

Actions

Vous revenez à l'affichage dans l'éditeur d'actions de test. Par défaut, cette possibilité n'est pas activée.

En-tête

Vous accédez aux informations dans l'en-tête du script :

Les éléments suivants sont affichés :

• Auteur : la personne ou le groupe qui a effectué le test.
• Description : définition du contenu du test. Ce champ accepte le code HTML. Vous pouvez également ajouter un ensemble de métadonnées qui seront reproduites telles quelles dans le script ATS : numéros des exigences, etc.
• Prérequis: quels sont les liens avec d'autres fichiers, ou la disponibilité des environnements, etc.
• Groupes: les groupes auxquels le test est affilié.

ATS code

Affichage du code brut ATS correspondant au test en cours d'édition.

Ce menu vous permet de copier le code du test pour l'envoyer par email à un correspondant qui pourra le rejouer.

Cet onglet ne permet pas de modifier directement le code ATS .

Lorsque vous recevez un email ou un fichier contenant le code ATS , la procédure pour l'importer dans Agilitest est la suivante :

• Créez un nouveau script vide
• Sélectionnez le code ATS dans votre éditeur de courrier électronique, notepad, etc ...
• Déposez le code directement dans la fenêtre vide de l'éditeur Agilitest
• Agilitest va lire le code et régénérer les actions correspondantes.
• Puis cliquez sur Exécuter ...

Code Java

Affichage du code Java généré lors de l'exécution du test. Évidemment, les fichiers java qui correspondent aux fichiers ATS des tests ne peuvent pas être modifiés directement.

Fermer

Fermer le script. Cela permet de l'enregistrer s'il n'a pas été sauvegardé.

Le menu de configuration d'Agilitest est la première page à visiter juste après une installation.

Voici les différents éléments que vous y trouverez :

Configuration de la langue

Ce menu permet de sélectionner la langue utilisée par l'interface d'Agilitest. Il nécessite un redémarrage de l'éditeur pour être pris en compte.

ATS configuration

Agilitest a besoin d'une bibliothèque ATS à jour pour fonctionner.

Ce menu vous permet de télécharger la dernière bibliothèque et est correctement configuré par défaut: il suffit de cliquer sur le bouton "Update".

Si vous voulez obtenir cette bibliothèque pour la positionner dans un répertoire spécifique, vous pouvez cliquer sur "Download ATS Components" : vous obtiendrez un fichier .zip que vous pourrez décompresser où vous voulez.

Enfin, le bouton "Modifier la configuration" vous permettra de spécifier en détail comment vous souhaitez que Agilitest et ATS s'interfacent avec vos applications.

Configuration de Java

Java est nécessaire pour faire fonctionner Agilitest, dans une version assez récente.

Ce menu vous permet de télécharger la dernière version que nous recommandons pour utiliser Agilitest. Elle est correctement configurée par défaut.

La configuration supplémentaire est pour ceux d'entre vous qui veulent appeler du code java dans les actions Agilitest et utiliser leur débogueur dans un IDE de type eclipse ou intelliJ.

Le port de débogage est celui que vous devez configurer dans votre éditeur. Vous pouvez également demander à Agilitest d'attendre la connexion à votre IDE lorsque le canal démarre. Attention de ne pas cocher cette option si vous n'avez pas d'IDE présent car vous risquez de ne pas pouvoir ouvrir votre canal si l'IDE ne répond pas.

Configuration de MAVEN

Ce menu vous permet de gérer directement les dépendances de ATS à l'aide de MAVEN. Il est réservé à un usage expert pour ceux qui souhaitent utiliser une version spécifique de ATS tout en permettant de récupérer l'ensemble de ses dépendances.

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur l'outil de capture :

‍

L'outil de capture Agilitest est un composant essentiel pour sélectionner les éléments de l'interface utilisateur à capturer et les réutiliser dans les tests comme cibles d'action.

‍

Qu'est ce que l'outil de capture ?

Lors d'un test manuel ou automatisé, il est essentiel de définir la cible de chaque action programmée dans le scénario. Par exemple, une action de clic nécessite un élément cible avec lequel interagir afin que le test clique sur le bon bouton, ou le bon élément d'interface.

L'outil de capture Agilitest définit ces cibles d'action. Il permet d'identifier les composants de vos applications, pour mettre en place des règles de détection adaptées avec les attributs pertinents.

L'outil de capture permet de survoler les éléments de l'interface graphique de votre web, mobile, desktop, ou les structures de données (XML pour vos webservices SOAP, JSON pour vos webservices REST).

Pour chaque élément ainsi survolé, l'outil de capture vous présente l'arbre dans lequel il se trouve, et les attributs qu'il possède.

‍

Qu'est-ce que le DOM ?

C'est le même outil de capture qui vous permet de capturer les balises HTML du DOM(Document Object Model) de vos applications web, les Widgets de vos applications de bureau ou mobiles, ou une présentation graphique des structures de données de vos webservices.

En ce sens, l'outil de capture Agilitest est graphique, polyvalent, et au service de l'aspect multicanal.

Le DOM est une représentation HTML d'une page web, qui définit la structuration des différents composants de la page.

Le DOM peut être vu comme un arbre où chaque élément peut avoir zéro ou plusieurs enfants, qui peuvent eux-mêmes avoir zéro ou plusieurs enfants.

Example : The DOM always starts from a root element: the <html> tag. This tag has children (<head>; <body>) which therefore have <html> in common as a parent. The content of your <body> tag can notably contain links, buttons, blocks etc.…

‍

💡 Conseil

Pour mieux comprendre le HTML :

• Opening tag <>, closing tag </>
• Élément, élément parent, élément enfant et élément frère.
• Processing a component of <iframe> type
• An <input> tag implies a parent <form> tag (often rich in attributes)
• A <li> tag implies a parent <ol> or <up> tag (often attribute-rich)
• ‍

Comment ouvrir l'outil de capture

Pour ouvrir l'outil de capture, vous devez d'abord démarrer un canal et avoir le site web ouvert dans le cadre d'un test web.

Une fois que vous avez créé votre projet et ouvert votre canal, vous pouvez ouvrir l'outil de capture en cliquant sur le bouton correspondant dans le canal menu de gestion.

Le filtre de capture est symbolisé par un pattern sous forme de petites croix qui sont positionnées devant le canal (l'écran de l'application à tester). Ce filtre sert à délimiter la zone de capture.

Un autre indicateur que l'outil de capture est activé est la fenêtre de capture qui apparaît en haut à gauche.

Vous pouvez appuyer sur la touche Shift de votre clavier pour cliquer sur des éléments de la page Web sans avoir à fermer l'outil de capture. Cela permettra d'ouvrir un menu déroulant ou d'afficher d'autres éléments qui n'apparaissent pas nécessairement.

‍

🔶 Avertissement

Le pattern correspond à la taille initiale de canal qui est définie dans sa configuration ATS . Si le canal est redimensionné manuellement, parfois la synchronisation avec le canal fonctionnera et le filtre correspondra à la taille modifiée du canal. Cependant, dans d'autres cas, le filtre ne correspondra pas à la taille du canal car il ne sera désynchronisé avec le driver canal. Il sera donc nécessaire de fermer le canal puis de le rouvrir pour que le driver se synchronise à nouveau.

‍

Utilisation de la capture

L'outil de capture Agilitest est composé d'une "fenêtre de capture".

Cette fenêtre peut être déplacée de gauche à droite, notamment lorsqu'elle cache un élément qui vous intéresse.

Cette fenêtre de capture est composée de 3 boutons principaux :

• Système (Alt): Bascule entre le mode de capture HTML et le mode de capture système. Par défaut, l'outil de capture sera placé sur la vue HTML. Pour changer de vue, vous pouvez cliquer sur le bouton système ou appuyer sur la touche ALT de votre clavier. Le changement de mode de capture nécessite le rechargement de l'outil de capture, ce qui peut prendre quelques secondes.
• Code source: Affiche le code source de la page.
• Fermer: Désactive le mode de capture.
• Les coordonnées x et y: correspondent aux coordonnées (x : abscisse et y : ordonnée) du curseur.

Le passage de la souris sur chaque élément de votre application est accompagné d'une info-bulle précisant son type (soit le nom de la balise HTML pour le web, soit le nom du composant GUI pour le bureau).

Pour capturer un élément, vous devez placer votre souris sur l'élément souhaité, puis appuyer sur la touche CTRL de votre clavier. Vous n'avez pas besoin de cliquer sur la souris, il suffit d'appuyer sur la touche CTRL.

Cela fera apparaître la fenêtre"Parents de l'élément capturé" qui affiche le chemin depuis la racine de l'application jusqu'à l'élément qui vient d'être ciblé.

Les éléments parents se déplient comme un accordéon pour afficher plus de détails sur les attributs. Les attributs doivent être cochés en fonction de ce que l'on souhaite conserver pour effectuer la détection de l'élément.

‍

‍

Lorsque la souris se déplace à travers les différents "nœuds" du chemin, le cadre bleu autour de votre élément dans la page Web se positionne pour identifier l'élément que vous avez déplacé.

Le composant est affiché avec tous les attributs qui le définissent. L'objectif est de sélectionner un ou plusieurs attributs qui définiront le composant et le feront reconnaître de manière unique dans la page. C'est ce qu'on appelle un "Locator".

‍

Les attributs

Les attributs sont : type, classe, id, nom, ou même des attributs CSS pour les applications web. Ou ils peuvent être : TitleBar, Button, TabItem pour les applications de bureau.

Agilitest ne propose que les attributs qu'il trouve. Cela signifie qu'il n'invente pas les ids, il les prend dans le DOM.

S'il n'y a pas d'id proposé, cela signifie que l'application est développée telle quelle. Deux situations possibles :

1. Les développeurs n'ont pas développé d'id, peut-être à cause du développement Agile ou par manque de temps. Vous pouvez donc leur donner un rapport sur votre test et leur dire si des ids sont manquants. En tant que QA, votre rôle est aussi d'auditer les bonnes pratiques et la qualité au sens large. En tant que testeur fonctionnel, il est plus de bon sens de faire remarquer aux développeurs que cela vous prend du temps qui n'est pas nécessaire pour identifier tel ou tel composant alors qu'un id serait un gain de temps dans la configuration de vos tests.
2. À l'inverse, si vous utilisez des cadres de développement, certains cadres n'ont pas de "bonnes pratiques" à respecter et n'ont donc pas d'identifiant.

‍

Fonctions avancées dans le locator

Une fois que les attributs permettant de définir votre composant sont sélectionnés, plusieurs étapes peuvent être réalisées avant de placer votre élément d'interface dans le script en ajoutant une action correspondante.

‍

Statistiques sur l'élément capturé

Dans la fenêtre"Parents de l'élément capturé", le bouton Statistiques vous permet de vérifier si les attributs cochés permettront de reconnaître de manière unique l'élément sur la page.

Un clic sur le bouton "Statistiques" confirme ou infirme l'unicité de l'élément vérifié selon la règle de détection choisie. Une coche verte apparaît pour confirmer l'unicité de l'élément. Il est possible de cliquer sur la loupe de la coche verte pour mettre en évidence l'élément sur la page web.

Si la coche verte n'apparaît pas lors de la vérification des statistiques, il y a plusieurs possibilités :

1. Occurrences multiples : Un avertissement apparaît pour signaler les occurrences multiples sur la page. Dans ce cas, vous pouvez ajouter de la précision et remonter dans les éléments supérieurs en ajoutant des attributs à votre élément ou, si plusieurs occurrences apparaissent, il est possible de cibler l'occurrence qui vous intéresse à partir de son numéro d'index.Exemple: Si une image apparaît toujours en 2ème occurrence dans l'ordre des composants de la page, alors vous pouvez sélectionner la 2ème occurrence parmi celles indiquées....
2. Une croix rouge : Cela signifie que l'élément n'est pas trouvé. Vous devrez trouver un autre moyen de reconnaître l'élément.

Expressions régulières (regex)

Les expressions régulières peuvent être utilisées dans l'outil de capture Agilitest pour faire correspondre des parties d'attributs. L'expression régulière vous permet de gérer des données dynamiques.

Une recherche basée sur un texte long n'est pas recommandée, car les espaces vides et les sauts de ligne peuvent entraîner des erreurs.

Exemple : Certaines bibliothèques JavaScript sont connues pour randomiser des parties d'identifiants ou de classes. Si nous regardons un identifiant écrit "btn-XYhSj02-01". Nous supposons que la première partie "btn" est fixe et la deuxième partie "01" également, seule la partie centrale est susceptible de varier.

Nous pouvons alors faire correspondre cet identifiant avec cette expression régulière :

btn -.{7}-01

L'utilisation des expressions régulières apporte une couche supplémentaire de difficulté, mais leur utilisation permet de traiter simplement les cas les plus délicats. La difficulté associée aux expressions régulières est donc un moindre mal.

Lorsque vous cliquez sur le texte d'un attribut, cela ouvre l'encart permettant de définir une expression régulière.

Accès à deux boutons pour :

• Gérer la casse des caractères
• Gérer les espaces

‍

💡 Conseil

Expressions à retenir :

(?i) : Signifie que l'expression est totalement insensible à la casse.

(?s) : Insensible au formatage des caractères spéciaux (sauts de ligne, espaces, etc.)

.* : Pour former n'importe quel caractère chaîne de caractère. Le point représente tous les caractères possibles (A-Z, 0-9 et caractères spéciaux) et l'étoile indique que le motif précédent (c'est-à-dire le point) est répété n fois.

[a-z]{3} : Means 3 letters between a to z.

‍

Déposer l'élément dans le script

L'icône "glisser-déposer" dans la fenêtre parent de l'élément capturé vous permet d'utiliser cette règle de détection dans l'élément d'une action Agilitest.

Le glisser-déposer peut être placé soit après les dernières lignes du test, ce qui créera une action,

Soit à l'intérieur d'une ligne d'action existante dans la section"Élément d'interface".

‍

Recherche d'un élément par son index

Lorsqu'un locator permet de retrouver plusieurs éléments, il est possible de préciser par un index celui que l'on veut manipuler.

Exemple : Dans un tableau où le nombre de rangées est représenté par l'élément "TR"Si vous spécifiez l'index #2 dans cet élément contenant plusieurs occurrences, alors le texte de la deuxième ligne du tableau sera récupéré.

Dans l'éditeur, remplissez l'index d'un élément multiple en cliquant sur l'icône Lego.

Ensuite, à droite de l'élément, vous verrez un # et deux contrôles haut/bas qui identifient par un index l'élément défini par votre locator.

En validant, Agilitest vous permet de récupérer des attributs spécifiques d'un élément identifié par son index.

‍

Reconnaissance graphique des éléments

La reconnaissance graphique est possible avec Agilitest, elle permet de détecter la présence d'un élément sur l'application et de compter le nombre d'occurrences (format PCRE). S'il n'est pas souhaitable d'abandonner le système de capture des attributs HTML, la reconnaissance graphique est complémentaire dans des cas d'utilisation spécifiques.

Exemple : Lorsque l'élément souhaité n'a pas d'id ou de classe utilisable, la reconnaissance graphique est utilisable.

Lorsque l'application comprend du code Java, Flash ou 3D, l'outil de capture ne sera pas toujours en mesure de plonger dans l'arborescence de l'application pour présenter les différents éléments de l'interface de manière structurée. Dans ce cas, la reconnaissance graphique permet d'effectuer des actions ou des contrôles même en présence d'un framework de programmation non coopératif avec Agilitest.

Pour utiliser la reconnaissance graphique, ouvrez l'outil de capture. Au lieu de vous positionner sur un composant et d'appuyer sur la touche CTRL, pour effectuer une capture graphique, vous devez sélectionner la zone que vous souhaitez capturer.

En utilisant la souris, maintenez votre clic gauche enfoncé pour sélectionner la zone à capturer

La sélection prendra une capture d'image de l'élément avec 3 boutons disponibles :

• Arbre des éléments
• Copier
• Enregistrer

Cliquez sur"Arbre des éléments" pour associer l'emplacement à la capture graphique puis faites glisser l'élément dans votre script et ajoutez-lui une action. Les possibilités sont les mêmes que pour un composant HTML classique.

‍

🔶 Avertissement

Cet outil doit être utilisé avec parcimonie ; il peut être utile pour agir sur un bouton qui n'est pas reconnu, par exemple, mais il peut interférer avec la reconnaissance graphique.

‍

L'intérêt d'un tel outil

Utiliser le code source d'une autre manière

L'outil de capture Agilitest offre des intérêts comparés au panel d'outils de développement offert par les navigateurs avec la touche F12 qui permet d'accéder au code source d'une page Web :

• L'outil de capture Agilitest est multi-navigateurs : Chrome, Firefox, IE, Edge, Opera sont traités de la même manière ;
• L'outil de capture Agilitest est multicanal et peut être utilisé sur : les applications web, les webservices, les applications de bureau, les applications mobiles ;
• L'outil de capture Agilitest ne se contente pas de survoler les éléments, il affine les règles de détection et teste leur unicité sur l'écran de l'application ;
• L'outil de capture Agilitest offre une reconnaissance graphique des éléments** en plus de la reconnaissance des attributs HTML.

‍

Locator Agilitest vs. XPaths

De nombreuses applications logicielles de test utilisent XPath comme système d'interrogation et de détection des éléments dans une application.

La détection est souvent assistée, et permet une relative facilité dans la création d'une expression XPath. L'expression XPath est créée et utilisée, souvent sans que le testeur ait eu l'occasion de la lire et de l'examiner dans le contexte de sa connaissance de l'application.

Un enregistreur permet, lorsqu'il est activé, d'ouvrir un navigateur et d'y effectuer des actions (clics, saisie de données, etc.) qui seront ensuite transformées en script par l'enregistreur.

L'outil de capture a la même finalité, seule la saisie est manuelle.

Un des avantages du Xpath est le côté "absolu" du chemin, qui permet de trouver exactement le composant grâce au détail du chemin indiqué.

Cependant, si un élément change au sein de ce chemin, cela entraînera une indication erronée vers le composant. Ceci est particulièrement vrai avec les frameworks Javascript (comme ExtJS) qui randomisent les identifiants des éléments, ce qui les rend difficiles à utiliser.

Exemple: Si les développeurs ajoutent un DIV au sein du parcours ou ont réorganisé les composants, l'attribut utilisé pour reconnaître le DIV a évolué.

En outre, les expressions XPath générées automatiquement peuvent être lourdes à maintenir.

Agilitest propose le contraire :

L'idée est de ralentir autant que possible la reconnaissance du composant. Moins vous ajoutez de composants, moins vous risquez de rendre le test obsolète aux changements futurs, ce qui rend le test plus robuste.

Ce sont, à notre avis, deux raisons de ne pas utiliser la technologie XPath dans Agilitest :

• Pas d'expressions XPath générées automatiquement sans examen par l'ingénieur en automatisation ou le testeur fonctionnel.
• Pas de test systématique de KO après la mise à jour de l'application.

‍

Vous pouvez regarder notre tutoriel ou vous pouvez consulter notre documentation sur les composants sélectionnés :

‍

Agilitest native gère les composants SELECT en HTML et les combo boxes pour les applications de bureau. Ceci est nécessaire car ces composants ont une interface graphique et un comportement particulier : il s'agit de sélectionner une ou plusieurs valeurs dans une liste déroulante.

Il y a 3 options possibles pour sélectionner une valeur :

Sélection de l'indice

L'indice correspond à la position de la valeur souhaitée dans la liste déroulante, en partant du haut et en commençant par 0.

Il suffit de cocher la case Index et de saisir la valeur souhaitée, évidemment cet index ne doit pas dépasser le nombre de valeurs proposées -1 sinon aucun texte ne sera sélectionné.

Sélection par texte

Dans ce cas, le texte sera sélectionné s'il correspond à une option possible proposée par le SELECT.

Cela permet de s'assurer de la valeur utilisée, mais il faut encore la proposer.

Sélection des valeurs

L'attribut value est une valeur supplémentaire qui est fournie dans le code HTML et qui est liée au texte affiché. Cela permet de sélectionner un texte, mais pas d'en récupérer la valeur.

Là encore, cette valeur doit être proposée pour que le texte correspondant soit sélectionné.

L'explorateur de projet Agilitest représente une arborescence physique de fichiers que vous trouverez telle quelle sur votre ordinateur.

Nous avons fait ce choix délibéré pour plusieurs raisons :

Un test correspond à un fichier ATS, lisible et modifiable, il est donc intéressant d'avoir cette correspondance pour pouvoir les utiliser directement depuis votre système d'exploitation.

Cette organisation vous permettra de gérer vos fichiers en dossiers et sous-dossiers sans grande complexité, et elle permet de gérer un très grand nombre de tests.

Enfin, nous sommes nous-mêmes sur un arbre de type MAVEN, afin de pouvoir profiter de la possibilité de gérer les dépendances pour qu'elles soient toujours à jour avec ATS, et que les personnes qui souhaitent l'utiliser avec Agilitest puissent le faire simplement.

Le contenu des répertoires

Voici le détail des principaux répertoires utiles qui composent l'explorateur de projets :

• libs : ce répertoire permet d'intégrer des bibliothèques non dépendantes de MAVEN que vous souhaitez utiliser avec votre projet de test.
• src\assets\data: Contient les fichiers CSV utilisés pour variabiliser vos scénarios et faire du Data Driven Testing.
• src\assests\resources\images: Ce répertoire stocke les images utilisées pour la reconnaissance graphique.
• src\assets\resources\lang: Ce répertoire comprend les différents fichiers de traduction que vous utilisez (par exemple dans vos fichiers vidéo)
• src\exec: Contient les fichiers d'exécutions que vous avez créés avec Agilitest. Ces fichiers peuvent être utilisés tels quels par Agilitest ou votre environnement d'intégration continue compatible avec TesNG.
• main\ats: Contient vos tests au format ATS , et les sous-répertoires que vous avez déclarés. Le nombre de fichiers .ats dans chaque répertoire est indiqué.
• main\java: Contient les fichiers de code java que vous souhaitez appeler à partir de vos scripts ATS .
• target\classes : contient le code compilé de vos fichiers java, ce qui inclut le code java généré par ATS et les fichiers java supplémentaires que vous avez importés.
• target\generated: le code ATS est transformé en java qui est généré dans ce répertoire avant d'être compilé.
• target\logs : Journaux d'exécutions générés par TesNG.
• target\output: Un ensemble de fichiers et de répertoires utilisés par TestNG pendant l'exécution des tests.
• target\report : Contient les fichiers ATSV (ATS video) qui sont générés à la demande pendant la relecture du test.
• target\report\<name_of_the_test> : Contains all the screenshots that are generated during a test replay, as well as an actions.xml file. All of these elements allow you to generate reports on demand in several formats, including pdf, using the XLST FOP engine.

Changer la vue de l'explorateur de projet

En sélectionnant le menu en haut à droite de l'explorateur de projet, vous pourrez modifier son affichage.

• Projets Explorer : Vue normale
• Afficher les images de ressources : Permet de voir en un coup d'œil toutes les images que vous avez utilisées pour la reconnaissance graphique.
• Afficher les scripts de ATS : Permet de voir uniquement vos scripts de test
• Afficher des rapports visuels : Permet de se concentrer sur les vidéos générées lors de l'exécution de vos tests.

Vous pouvez regarder notre tutoriel ou consulter notre documentation sur la modification des actions :

‍

Nous discuterons des possibilités de publication de l'éditeur Agilitest.

La simplicité de l'affichage

L'éditeur Agilitest a été conçu pour vous montrer la plupart des actions que vous déclarez dans vos tests, pour les détails, il suffit généralement de cliquer sur les éléments affichés pour faire apparaître une fenêtre complémentaire qui permet d'entrer dans les détails.

Il existe une notion d'action active : elle s'affiche en surbrillance. Toutes les actions ajoutant des opérations seront basées sur cette notion.

Il est possible de sélectionner plusieurs actions actives : pour cela, sélectionnez la première action, appuyez sur la touche SHIFT de votre clavier et sélectionnez la dernière : toutes les actions entre ces deux actions seront sélectionnées.

En utilisant la touche CTRL, il est possible de sélectionner séparément une ou plusieurs actions à ajouter au groupe d'actions actives.

La création de nouvelles actions

Il existe trois façons de créer de nouvelles actions :

En cliquant sur le menu d'actions

Vous ajoutez une nouvelle action sous l'action active ou la dernière action active. Cette nouvelle action apparaît vide de toute information. Il faudra alors la compléter manuellement ou en y déposant de nouveaux éléments.

En laissant tomber un objet capturé sur l'application testée.

Il suffit de placer la souris dans la partie inférieure de l'action sous laquelle vous voulez créer la nouvelle action pour afficher un menu "Créer une action".

Ensuite, l'action générée est liée à un élément graphique de votre application : tous les types d'action ne sont pas accessibles de cette manière.

Utilisation de la fonction copier-coller

En cliquant avec le bouton droit de la souris sur une action ou un groupe d'actions actives, vous pouvez afficher un menu contextuel.

Ce menu vous permettra de couper / copier et coller, ou même de supprimer les actions sélectionnées.

Une autre option permet d'activer ou de désactiver une ou plusieurs actions : leur affichage sera grisé et elles ne seront pas rejouées dans le test.

Actions liées aux éléments de l'application

Toutes les actions liées aux éléments de l'application testée comportent un lien vers un élément d'interface (issu de l'interface utilisateur du logiciel testé).

Pour ces actions, la partie supérieure concerne l'action effectuée, et son sous-menu est lié à la spécificité de cette action.

Le menu contextuel lié à l'élément d'interface permet de modifier, ou de spécifier entièrement manuellement le locator qui permet de retrouver l'élément dans la page :

En survolant et en cliquant sur l'élément, vous verrez apparaître un menu contextuel avec les options suivantes :

Action sur l'élément

En cliquant sur l'élément, vous pouvez ajouter des parents, des enfants, spécifier leur type entièrement manuellement.

En cliquant sur la petite icône en forme de lego à droite, vous pouvez ajouter des attributs à l'élément.

Enfin, un clic sur le # dans le menu de modification de locator vous permettra d'indiquer quel élément sélectionner par ordre d'apparition lorsque votre locator permet de récupérer plusieurs éléments de la page. Cette fonctionnalité est utile pour sélectionner une ligne ou une colonne spécifique dans un tableau par exemple. Les valeurs positives sont dans l'ordre du visuel du locator alors que les valeurs négatives partent de la dernière valeur identifiée à la première du locator.

Glisser-déposer d'un élément

En cliquant sur la bannière sombre de l'élément d'interface, vous pourrez le glisser-déposer dans une nouvelle action.

Ceci est très utile pour réutiliser des éléments d'interface qui ont déjà été déclarés précédemment

Aucun élément

Si vous supprimez toute définition des éléments d'interface de votre application, vous affichez la notion de racine de l'application, avec les possibilités suivantes :

• Ajout d'un élément d'interface: Correspond aux cas présentés ci-dessus.

• Cliquez sur un bouton du système: Cela vous permet d'envoyer un événement de clic directement aux composants graphiques de votre navigateur.

• Gère une boîte de dialogue modale de type alerte ou config : Permet d'accepter ou de refuser l'affichage de la boîte de dialogue

• Ajouter un locator à un élément d'interface du système: Cette fonction est liée aux localisateurs de type desktop. Il est accessible de faire des modifications manuelles, mais nous vous conseillons plutôt de passer par le pilote de bureau.

Options d'action

Un ensemble de fonctions supplémentaires sont disponibles sur une ligne d'action et vous permettront de :

• Ajouter un point d'arrêt lors de l'exécution du test, à des fins de débogage. Il suffit de cliquer sur le panneau STOP

• Augmenter ou diminuer le nombre maximum d'essais. Ceci indique à Agilitest qu'il doit essayer plusieurs fois d'attendre le retour de l'application avant de générer un échec. Par défaut la valeur est fixée à 15, les valeurs possibles sont de -10 à 50, et il faut savoir que plus la valeur est élevée, plus Agilitest attendra entre deux essais.

• Indiquez à Agilitest que cette action peut échouer : en cliquant sur le carré en haut à droite, vous verrez une double flèche verte indiquant que l'action peut échouer sans que le test échoue. Cette fonctionnalité est nécessaire pour compenser certains comportements sporadiques des applications, par exemple une popup qui ne s'affiche pas tout le temps.

Agilitest supporte l'automatisation des applications web sur 5 navigateurs :

• Chrome
• Firefox
• Microsoft Edge
• Internet Explorer
• Opéra

En outre, nous assurons une compatibilité générique avec les navigateurs issus de Chromium, par exemple JXBrowser.

Créer un premier test

Pour commencer, vous devez ouvrir un canal sur le navigateur web de votre choix. Par défaut Agilitest trouvera l'installation des principaux navigateurs du marché, à l'exception d'Opera qui nécessitera une petite configuration supplémentaire.

En cliquant sur le bouton "Démarrer le canal", vous pourrez sélectionner le navigateur qui vous intéresse.

Vous pouvez ensuite ouvrir immédiatement le site canal en cliquant sur le bouton "Play" qui apparaît à droite de l'action : l 'ouverture du site canal lancera le navigateur.

L'action suivante "Navigation -> Browser URL" vous permet de spécifierà quelle URL se trouve votre application, il peut s'agir d'un lien local ou d'un lien Internet.

Après avoir spécifié votre URL, il suffit de lancer directement l'action pour que votre navigateur se positionne sur la page souhaitée.

A partir de là, vous devrez passer en mode capture pour sélectionner des éléments du DOM, effectuer des actions et des contrôles, et finaliser votre test.

Comment exécuter le même test sur plusieurs navigateurs ?

Une fois votre premier test effectué, vous pouvez très facilement le lancer sur plusieurs navigateurs, pour cela faites les opérations suivantes :

Créez un fichier CSV d'une seule colonne et remplissez les navigateurs qui vous intéressent. Pour ce faire, il suffit de cliquer sur "Nouveau composant" et sur le fichier csv.

Nous allons ensuite itérer sur les valeurs du fichier CSV en effectuant un appel d'indice.

• Créez un nouveau script
• Déposez votre script principal depuis l'explorateur de projet dans la fenêtre d'édition, cela créera une action "Appeler le script".
• Déposez le fichier CSV sur cette nouvelle action, pour générer un appel itératif sur le fichier CSV.

Il suffit de modifier légèrement votre script initial, afin de faire varier le nom du navigateur : cliquez sur la section App de l'action "démarrer un canal", et remplacez le nom du navigateur, mis en dur, par la variable $param(0), il s'agit de la valeur de la première colonne de votre fichier CSV sur laquelle votre appel de sous-script sera itéré.

Dans Agilitest, vous pouvez utiliser des variables à plusieurs endroits afin d'augmenter la réutilisation des scripts et des fichiers, vous aurez plus d'informations en consultant notre documentation sur les tests pilotés par les données.

Il est important que l'analyse des conditions d'échec d'un test soit rapide et efficace pour déterminer si le test doit être modifié ou s'il existe une condition de régression dans le logiciel.

Ce point est crucial pour réduire encore la charge des tests automatisés sur le site maintenance .

C'est pourquoi nous avons fourni à Agilitest un module de génération de vidéos lors de la relecture des tests.

Cette fonctionnalité est fournie par ATS de manière native : c'est open source. Vous pourrez échanger vos rapports avec vos partenaires même s'ils n'ont pas accès à Agilitest.

Comment produire un rapport vidéo dans Agilitest ?

Il y a plusieurs façons de produire un rapport vidéo directement dans Agilitest.

En passant par les paramètres d'exécution de la gestion canal

Cette fonction est accessible à gauche de l'éditeur Agilitest et vous permet de demander la génération d'un rapport pendant une exécution.

• Cliquez sur Paramètres et sélectionnez Rapport visuel
• Cliquez ensuite sur Exécuter
• A la fin de l'exécution, le rapport est accessible avec l'explorateur de projet dans le répertoire target\report.

En double cliquant sur le fichier ATSV généré, le rapport vidéo est lu dans la visionneuse fournie avec Agilitest.

Utilisation du menu des exécutions

Dans le panneau de contrôle de l'exécution, vous pourrez demander la génération de Rapports vidéo.

Vous aurez accès à des options supplémentaires concernant la qualité de l'application générée Rapports vidéo. Il est important de configurer correctement ce point car cela peut affecter le temps d'exécution ou la taille de Rapports vidéo lors de la relecture des tests d'intégration continue.

Le format ATSV a été optimisé pour ne pas prendre beaucoup de place et être généré rapidement, mais sachez que la configuration des vidéos dans les exécutions concerne tous les tests qui seront rejoués et peut produire une grande quantité de rapports.

Comment lire une vidéo ATSV sans Agilitest ?

Un lecteur ATSV écrit en HTML5 / Javascript est fourni gratuitement et peut être intégré directement dans vos environnements d'intégration continue, ou même lancé en ligne de commande.

Vous pouvez l'utiliser en suivant ce lien :

http://www.actiontestscript.com/dev/player/

Le menu d'action d'Agilitest est central et vous permet de déclarer manuellement toutes les actions possibles dans un script de test.

‍

Types d'actions

‍

‍

‍

Action des chaînes

‍

‍

Ces actions vous permettent de créer, fermer et modifier le canal de votre test. Elles sont intégrées directement dans le script.

Démarrer un canal: Cette action permet à Agilitest de faire le lien avec l'application testée.

Changez vers le canal: Cette action est utilisée lorsque plusieurs canaux sont présents dans le script. Elle permet de passer d'un canal à l'autre.

Arrêtez le canal: Ceci indique à Agilitest que le site canal ne sera plus utilisé pendant ce test et fermera l'application.

‍

‍

‍

Actions de navigation

‍

‍

Dans le cas de l'automatisation d'applications sur des services distants, Web et Webservices, ces actions vous permettront d'indiquer vers quelle URL naviguer et quel protocole sélectionner : Web / HTTP, SOAP, REST.

‍

🔸 Avertissement

Dans le cas d'une exécution sur le bureau, vous devrez toujours passer par l'action "Browser URL" en saisissant le chemin de l'application testée dans l'explorateur Windows.

‍

‍

‍

Action de sous-script

‍

‍

Cette action n'a pas de menu déroulant car elle crée directement une action d'appel de script dans le script. Les sous-scripts ne diffèrent pas des scripts, les deux sont des fichiers ats , seul l'un est appelé par l'autre.

Il y a deux façons d'utiliser cette action :

• En effectuant un appel direct avec ou sans paramètres
• À partir d'un fichier CSV/JSON

‍

‍

‍

Action de saisie de texte

‍

‍

L'action de saisie de texte envoie à votre application les éléments correspondant aux touches du clavier à votre application. L'action de saisie de texte envoie à votre application les éléments correspondant aux touches du clavier, les pressions sur les touches, avec ou sans touches spéciales supplémentaires.

Cette action est insérée directement dans votre script. A partir de l'action, vous pouvez définir la nature de l'action.

Cliquez sur l'action "Saisir un texte [ ]" pour saisir un texte.

Vous pouvez écrire directement le texte désiré à l'aide de votre clavier. Vous avez également accès aux touches spéciales qui ont les mêmes fonctions que celles présentes sur le clavier (entrée, espace, CTRL, etc...).

Vous pouvez également insérer des valeurs spéciales dans votre saisie de texte à partir du menu des valeurs spéciales.

Cela vous permettra d'accéder à diverses valeurs, variables, etc...

‍

‍

‍

Actions de la souris

‍

‍

Les actions de la souris sont utilisées pour gérer la souris sur les applications PC, mais aussi les actions spécifiques des applications mobiles telles que le swipe.

Cette action comporte un sous-menu comprenant :

• Clic de souris: Il s'agit d'un clic sur un élément
• Survol: Il simule le survol de la souris
• Glisser-déposer: cette action contient un sous-menu qui la complète :
• Glisser: permet d'effectuer un clic de maintien
• Déposer: Cette action libère l'élément. Elle doit être précédée d'une action de "glisser".
• Balayage: Balayer vers la droite, la gauche, le haut ou le bas à l'aide de la souris ou en simulant le toucher pour les tests web.
• Défiler: Pour faire défiler un curseur ou accéder à des éléments d'une page

‍

‍

‍

Vérifier les actions

‍

‍

Les actions de vérifications sont générées pour un contrôle explicite ou une assertion pendant le test. Cela peut potentiellement conduire à l'échec du test ou lui permettre de continuer.

Trois actions de vérification sont possibles :

• Vérification de la propriété: Cette fonction permet de vérifier la valeur d'une propriété existante dans le script.

‍

• Vérification des occurrences: Cette fonction permet de vérifier le nombre d'occurrences d'un élément.

‍

• Vérification des valeurs: Cette fonction permet de vérifier qu'une valeur correspond à une valeur existante dans le script.

‍

‍

‍

Action de propriété

‍

‍

L'action propriété vous permet, à partir d'un composant capturé, de récupérer une de ses propriétés et de la placer dans une variable.

Cette variable peut ensuite être utilisée pour définir d'autres variables dépendantes, créer des assertions, etc.

‍

‍

‍

Actions du système

‍

‍

Les actions du système ne sont utilisées que pour un canal mobile.

Cette action s'effectue de deux manières :

• En utilisant l'action du bouton: Cela vous permet d'interagir avec un bouton physique du téléphone (réglage du son, accueil, verrouillage, etc.).
• En définissant les propriétés: Cela vous permet de définir une propriété du système ( niveau du volume sonore, orientation du téléphone, activation/désactivation du WIFI, etc...).

‍

‍

‍

Actions sur les fenêtres

‍

‍

L'action de gestion des fenêtres vous permet de gérer le système d'exploitation Windows, les applications modales du bureau Windows et les onglets du navigateur.

Il ne permet pas de gérer les fenêtres internes de certaines applications web, qui sont des éléments HTML flottants, directement accessibles avec les automatismes web.

Un menu spécifique est également disponible pour gérer les boîtes de dialogue sans ajouter de complexité inutile.

L'action de la fenêtre comporte un sous-menu avec trois actions possibles :

• Taille et emplacement: Cette fonction permet de déplacer la fenêtre en spécifiant ses nouvelles coordonnées cartésiennes ou de modifier sa taille (hauteur et largeur).
• État visuel de la fenêtre: Cela vous permet d'envoyer un événement du système d'exploitation à la fenêtre en cours.
• Changer de fenêtre: Cette fonction permet de changer la fenêtre actuelle en spécifiant le numéro de la fenêtre qui doit être permutée.

‍

‍

‍

L'action sélectionner

‍

‍

Cette action gère des composants SELECT spécifiques dans les navigateurs web ou des COMBO-BOXES dans les applications de bureau.

‍

‍

‍

Action de script

‍

‍

Les scripts sont utilisés pour exécuter Javascript sur un composant.

Elle diffère de l'action d'exécution Java qui se produit en dehors du contexte d'un composant (mais qui peut toujours récupérer des variables).

‍

‍

‍

Actions de commentaire

‍

‍

En plus de simples commentaires techniques, cette action vous permettra de déclarer les étapes fonctionnelles clés de votre test.

Cette action comporte quatre types de commentaires :

• Étape fonctionnelle: Ce commentaire indique une étape importante du script
• Commentaire du script : Ce commentaire explique les opérations effectuées par le script
• Journal d'exécution: Ce commentaire est fonctionnel le chaines de caractères
• Résumé du rapport: permet d'ajouter du texte au résumé du rapport d'exécution généré.

‍

‍

Certaines de ces actions peuvent agir directement sur un composant et peuvent être créées à partir d'un élément capturé et déposé dans le script.

Ces actions sont les suivantes : Actions de vérification, actions de la souris, actions de saisie de texte, actions de propriété, actions Javascript et actions de sélection.

‍

Pour vous aider à vous familiariser avec notre application, voici les différents éléments qui la composent :

Menu de gestion de projet

Ce menu vous permet de créer un projet, d'ouvrir un projet existant, de créer un nouveau composant et d'enregistrer les fichiers sur lesquels vous travaillez.

Lorsque vous créez un nouveau composant, Agilitest vous permet de sélectionner les types suivants :

Nouveau script ATS : Créer un nouveau test ou sous-script.

Créer un fichier CSV: Créez un fichier de données vous permettant de tester sur plusieurs données. (Voir notre section Data Driven Testing)

Nouveau script java: Permet d'appeler du code Java externe à Agilitest.

Créer une exécution : Permet de créer une exécution de vos tests pour gérer la relecture de tous les tests d'un projet filtrés selon de multiples critères.

Menu de configuration et aide

Ce menu est le premier à visiter pour s'assurer de la bonne configuration de votre éditeur.

Il vous permettra de mettre à jour toutes les dépendances d'Agilitest (ATS, java, FOP, etc...).

Pour ceux qui veulent aller un peu plus loin dans la configuration de leur éditeur, vous pouvez modifier la configuration de ATS en personnalisant le fichier .atsProperties.

La page d'aide vous permettra d'accéder à de nombreuses ressources, dont un exemple de projet.

Vous pouvez également accéder à des informations sur le poste de travail sur lequel Agilitest est déployé et télécharger des outils supplémentaires.

L'explorateur de projets

L'explorateur de projet est situé sur le côté gauche et vous permettra d'accéder à tous les fichiers qui composent votre projet.

Vous aurez également accès à la gestion de l'exécution liée à un projet donné.

Gestion des canaux

Le menu de gestion canal est un pré-requis avant de commencer à éditer un test, c'est un élément central d'Agilitest et qui va faciliter la création et maintenance des tests.

Gestion des variables

Le menu de gestion des variables vous permet de visualiser d'un coup d'œil toutes les variables utilisées dans un script.

Cela permet d'éviter de retrouver ces variables dans le corps du script qui est réservé aux actions et aux contrôles.

Menu Actions

Le menu des actions est central et vous permet d'ajouter tous les types d'actions possibles qui peuvent être effectuées sur un test.

Il a été conçu pour permettre une compatibilité maximale entre toutes les technologies supportées par Agilitest.

Ce menu permet également de gérer les différents canaux utilisés dans un test.

La partie édition

La section d'édition d'Agilitest représente une grande partie de l'éditeur et affiche les actions que vous effectuez sur vos tests.

Cette section de l'éditeur a été particulièrement étudiée pour permettre la réutilisation des composants: copie des actions ou des éléments sur lesquels elles agissent, création de sous-scripts.

Nous avons également simplifié l'affichage pour n'imprimer que les actions principales, mais tous les cas possibles sont gérés dans des sous-menus.

En-tête de script

Le menu d'en-tête de script vous permet de gérer un ensemble de métadonnées liées à un test, comme les groupes d'exécution.

Vous pourrez visualiser le script ATS correspondant à votre test pour le copier et l'envoyer par mail ou l'ajouter à un commentaire dans votre outil de gestion bug .

Vous pourrez également accéder au code java qui, compilé, permet l'exécution des tests. ATS et les scripts java ne peuvent pas être édités directement dans l'éditeur.

Une icône vous permet de fermer le script.

ActionTestScript, diminutif de ATS est un langage de test structuré, lisible et compréhensible par un être humain et facilement modifiable par une I.A. utilisé pour créer des campagnes de test automatisées fiables et puissantes avec une interface graphique.

ATS est un logiciel libre sous la licence Apache 2.0.

Les scripts de test sont définis par une séquence d'"actions" exécutées sur une application Web (Chrome, Edge, Internet Explorer 11, Firefox et Opera), un ordinateur de bureau (Desktop), un mobile ou Webservice.

Les scripts écrits en ATS sont convertis en classes java puis exécutés à l'aide des frameworks Selenium (pour les navigateurs), ou par des couches logicielles directement implémentées pour les parties bureau, mobile Android et iOS ou les Webservices.

ATS produit des rapports dans les formats suivants :

• Fichiers vidéo ATSV
• Rapport XML qui peut être converti (pdf...)

ATS est compatible avec le format d'exécution TestNG largement utilisé et est compatible avec la plupart des systèmes d'intégration continue récents.

Avec ATS, les concepteurs de tests se concentrent uniquement sur les actions fonctionnelles à réaliser et n'ont pas à se soucier des considérations techniques.

Le lien entre ATS et Agilitest

Le lien est avant tout philosophique : nous avons voulu mettre à la disposition de tous la technologie de relecture des tests logiciels qui est ATS et permettre ainsi une accélération possible des développements qui sont liés : les technologies liées au dev/ops et plus généralement tous les acteurs de la chaîne de production des logiciels sont multiples et encore en forte évolution.

Techniquement, Agilitest est un éditeur qui produit des scripts ATS , mais nous avons aussi mis dans cet éditeur toute l'expérience de plusieurs années d'utilisation d'outils de tests automatisés. Il s'appuie sur ATS et bénéficie des caractéristiques techniques qu'il apporte : lisibilité des scripts, relecture pas à pas des tests, robustesse...

ATS est maintenu par Pierre HUBER, fondateur de CAIPTURE, éditeur d'Agilitest. Plus d'informations en suivant le lien :

www.actiontestscript.com

Vous pouvez regarder notre tutoriel ou vous pouvez parcourir notre documentation sur l'intégration de Jenkins :

‍

Il existe plusieurs façons de lancer les tests d'un ATS projet : tout comme avec Jenkins, plusieurs solutions sont possibles.

Nous allons présenter ici une solution très simple qui ne nécessite que quelques minutes d'installation et de configuration.

N'utilisez cette procédure que si vous avez besoin d'une installation spécifique de Jenkins : Agilitest est capable de télécharger automatiquement, d'installer une instance de Jenkins et de configurer les travaux sur l'ordinateur où il s'exécute.

Installation de Jenkins

• Téléchargez un Jenkins pour Windows ici : https://jenkins.io/download/
• L'installer en standard
• Lancez-le en ligne de commande avec java (ne le lancez pas en service pour cet exemple de configuration et si nécessaire, arrêtez le service Jenkins).
• Exemple de commande pour lancer Jenkins : java -jar -Xms768m -Xmx1024m jenkins.war
• Connectez-vous à "http : // localhost : 8080" et suivez les instructions pour le mot de passe.
  Attention : le mot de passe initial lors du lancement manuel est modifié et imprimé dans les journaux de lancement.
• Vous pouvez ensuite choisir d'"installer les plugins suggérés" ou d'installer les plugins de votre choix.
• Saisissez ensuite les informations du compte administrateur et cliquez sur "Enregistrer et continuer".
• Configurez l'instance (adresse et port) puis cliquez sur "Terminer".
• Votre instance Jenkins est prête à être personnalisée.

Configurer un JDK (minimum 10)

À l'aide d'un navigateur, connectez-vous à votre instance Jenkins.

(dans certains cas, si vous avez un écran vide, redémarrez votre instance de ligne de commande).

• Cliquez sur "Manage Jenkins" puis choisissez "Global Tool Configuration" : dans la section "JDK" choisissez le JDK que vous voulez utiliser (minimum 10), soit automatiquement proposé par Jenkins, soit en définissant un répertoire local contenant un JDK 10 .

Installation de plugins :

À partir de "Manage Jenkins", cliquez sur "Manage Plugins". Les plugins nécessaires pour ATS sont :

• Plugin d'injection d'environnement
• Plugin d'intégration GitHub
• Plugin Maven Invoker
• Plugin TestNG Results
• Plugin Maven Unleash
  

(Note : Vous pouvez ajouter tous les plugins qui vous intéressent)

• Dans la section "Available", filtrez avec les noms des plugins ci-dessus pour les sélectionner :

(Ces plugins seront normalement déjà installés sur la plupart des infrastructures Jenkins existantes, à l'exception peut-être de TestNG).

L'installation de ces plugins récupère toutes les dépendances nécessaires.

Définir le répertoire ATS

Prérequis : Télécharger les composants ATS (Plus d'informations sur le projet GitHub Action Test Script dans la section "installation")

Dans le menu "Manage Jenkins", cliquez sur "Configure System" puis dans la section "Global Properties" ajoutez une variable d'environnement :

Nom = ATS_HOME
Valeur =[chemin vers votre répertoire local ATS]

• Retour à la page d'accueil de Jenkins
• Cliquez sur"Nouvel élément".
• Nommez votre nouvel emploi
• Cliquez sur"Maven Project" puis sur OK.

• Dans la section"Gestion du code source", cliquez sur le bouton radio "git" et entrez l'URL git d'un projet ATS (par exemple : https://github.com/pierrehub2b/ats_test.git ).
• Vous pouvez également cliquer sur "aucun" pour utiliser un projet local (le chemin sera défini dans le fichier POM de votre projet).

• Dans la section "Build Environment", ajoutez éventuellement une variable (par exemple browser.name = chrome) après avoir coché : "injecter des variables d'environnement au processus de construction"

• Pour être utilisé par ATS, ce nom de variable doit être le même qu'une variable utilisée dans le projet ATS . (par exemple, dans l'éditeur Agilitest vous trouverez ces variables dans la partie "Paramètres d'exécution" d'un projet)

• Sur jenkins, dans la section"Build", entrez la valeur "test" dans le champ "Goals and options" :

• Votre travail est configuré et est prêt à être lancé en cliquant sur "Build Now" :

• Une fois le travail terminé, vous aurez accès aux rapports habituels résultant de l'exécution des tests (détails par tests, régressions, réussis, échoués etc...).

Si vous souhaitez partager ou échanger sur un autre exemple de configuration, vous pouvez le faire via le projet github suivant: https://github.com/pierrehub2b/actiontestscript.

Dans vos tests fonctionnels sur des terminaux mobiles, vous aurez parfois besoin d'automatiser des actions atypiques liées notamment à l'OS.

Pour cela, nous avons intégré les fonctions natives suivantes :

• Retour: Retour sur la dernière action
• Accueil: Affiche le "bureau" du terminal mobile
• Menu: Accès aux fonctions du bureau du terminal mobile
• Recherche: Lance une recherche google sur le terminal mobile.
• Supprimer: supprimer le dernier caractère saisi
• App: Affiche la liste des applications récemment lancées sur le terminal mobile.

Pour ajouter ces actions, procédez comme suit :

• Sélectionnez "Application root".

• Sélectionnez "Bouton système".

• Sélectionnez la bonne action système pour votre test

Détails des actions disponibles

Retour

Cette action correspond à l'utilisation du bouton physique généralement présent sur les terminaux Android.

Il est particulièrement utile pour réduire le clavier virtuel qui se déploie parfois automatiquement sans qu'il soit nécessaire de cliquer sur un bouton particulier.

Entrez

Cette action correspond à l'utilisation du bouton physique "Entrer" sur les terminaux.

Accueil

Cette action correspond à l'utilisation du bouton physique généralement présent sur les terminaux Android.

Réduit toutes les applications en cours pour atteindre rapidement le "bureau" du terminal mobile.

Menu

Cette action correspond à l'utilisation du bouton physique généralement présent sur les terminaux Android.

Il est particulièrement utile pour accéder aux options de configuration du "bureau" du terminal mobile.

Action effective uniquement depuis le système d'exploitation (sans effet sur une application).

Recherche

Cette action correspond à l'utilisation de la fonction "recherche" généralement proposée sur les terminaux Android.

Action effective uniquement depuis le système d'exploitation (sans effet sur une application).

Supprimer

Cette action vous permet de supprimer le dernier caractère saisi dans l'élément en cours de sélection.

Cette action ne détecte aucun élément sur l'application.

App

Affiche la liste des applications récemment lancées sur le terminal mobile.

Cette action peut être utile pour effectuer un passage rapide sur une application native du terminal mobile et revenir à l'application testée.

Dans vos tests fonctionnels de bout en bout, vous pouvez gérer les flux de services Web directement dans vos scripts de test automatique Agilitest/ATS .

L'objectif est que vous puissiez contrôler les données échangées ou même les récupérer pour les réutiliser à des fins fonctionnelles dans vos tests automatiques.

Écriture de l'appel Web Service dans Agilitest

Pour ce faire, il suffit de saisir l'action"Démarrer le canal" avec le lien http complet de votre demande Web Service :

Exemple ici : http://webservices.oorsprong.org/websamples.countryinfo/CountryInfoService.wso?WSDL

L'exécution de cette action"Démarrer le canal" ouvrira automatiquement un visualiseur spécifique qui vous permettra de capturer toutes les données que vous souhaitez vérifier et/ou récupérer dans ce flux Web Service .

Agilitest détectera automatiquement s'il s'agit de SOAP ou de REST (dans lequel tous les autres types de services qui ne sont pas SOAP seront également inclus).

Cette fenêtre de capture communiquera toutes les actions disponibles sur le site Web Service:

En écrivant la méthode adressée à ce Web Service dans Agilitest

La deuxième action spécifique de Web Service se trouve sur la "Navigation" et REST ou SOAP Webservice

L'action REST est par défaut GET, mais toutes les méthodes HTTP de la norme sont disponibles : Get, Post, Delete, Patch et Put.

Vous pouvez enrichir la requête soit par la méthode (URL), soit par les paramètres de l'API, soit par les en-têtes, soit tout cela à la fois.

Vous pouvez passer manuellement au type SOAP via le bouton dédié :

Pour tous les services Web, vous pouvez selon vos besoins.

• Envoyer les demandes directement via la méthode (c'est-à-dire le lien html dans lequel vous avez rempli les informations souhaitées).
• Utilisez la case"Données API" pour compléter, complexifier ou clarifier la requête.

• Utilisez la case "En-tête de la demande" pour gérer les en-têtes si nécessaire.

Il existe deux paramètres supplémentaires que vous pouvez utiliser :

• Changer de port: Permet d'indiquer sur quel port vous souhaitez interroger le site webservice.
• Utilisez le cache: Dans la mesure du possible, Agilitest ne fera pas de nouvelle demande si les données demandées sont déjà dans le cache.

Si vous ne connaissez pas l'ensemble des actions disponibles : le plugin Wizdler

Si vous ne connaissez pas le corps du site Web Service, voici une astuce simple pour vous aider à analyser les fichiers WSDL et à générer des messages SOAP :

1. Installez le plugin WIZDLER sur votre navigateur web (Chrome par exemple : Lien vers le plugin Wizdler ici)
2. Ouvrez votre lien http Web Service sur le même navigateur.
3. Cliquez sur le bouton Wizdler dédié :

       4. Cliquez sur l'une des actions disponibles sur ce site Web Service (par exemple CapitalCity) pour récupérer le corps et le coller dans la case "Paramètres API".

         5. N'oubliez pas d'indiquer l'action connexe dans la "méthode" de l'action Agilitest.

          6. Vous pouvez même tester l'action en remplaçant les données par défaut[chaîne de caractère], puis en cliquant sur le bouton "Go" dédié et en vérifiant le résultat renvoyé par la fonction Web Service

Capture des données renvoyées par le Web Service

Maintenant que la"méthode" et la case"Paramètres API" de votre action sont remplies, Agilitest sera en mesure d'exécuter automatiquement l'action dans votre flux fonctionnel.

Vous pouvez capturer le résultat de la requête via le mode capture d'Agilitest.

L'action "Propriété" vous permet de réutiliser les données cibles renvoyées par le site Web Service dans votre script :

La récupération de l'attribut "valeur" nous permet dans ce cas de récupérer la Capitale du Pays dont le code ISO est FR, à savoir Paris.

Note

Les actions de vérification et de récupération des propriété seront très souvent les actions les plus pertinentes dans l'écriture de vos tests fonctionnels de bout en bout utilisant des services Web.

Exemple de script SOAP

Veuillez trouver ici un exemple de script SOAP ats : SOAP_flag_demo.ats
Faites un clic droit sur le lien ci-dessus et sélectionnez "Enregistrer le lien sous..." pour récupérer le fichier ATS .

Vous pouvez l'ajouter à votre projet Agilitest pour le modifier et/ou l'exécuter.