QTP - Guide rapide
QTP signifie QbonTest Pprofessionnel, un produit de Hewlett PAckard (HP). Cet outil aide les testeurs à effectuer un test fonctionnel automatisé de manière transparente, sans surveillance, une fois le développement du script terminé.
Utilisations de HP QTP Visual Basic Scripting (VBScript)pour automatiser les applications. Le moteur de script n'a pas besoin d'être installé exclusivement, car il fait partie du système d'exploitation Windows. La version actuelle de VBScript est la 5.8, qui est disponible dans le cadre de Win 7. VBScript n'est PAS un langage orienté objet mais un langage basé sur objet.
Outils de test
Les outils issus d'un contexte de test logiciel peuvent être définis comme un produit prenant en charge une ou plusieurs activités de test, depuis la planification, les exigences, la création d'une construction, l'exécution de tests, la journalisation des défauts et l'analyse des tests.
Classification des outils
Les outils peuvent être classés en fonction de plusieurs paramètres. Il comprend -
- Le but de l'outil
- Les activités prises en charge dans l'outil
- Le type / niveau de test qu'il prend en charge.
- Le type de licence (open source, freeware, commercial)
- La technologie utilisée
Types d'outils
Sr.No. | Type d'outil | Utilisé pour | Utilisé par |
---|---|---|---|
1 | Outil de gestion des tests | Gestion des tests, planification, journalisation des défauts, suivi et analyse. | Testeurs |
2 | Outil de gestion de la configuration | Pour la mise en œuvre, l'exécution, le suivi des modifications | Tous les membres de l'équipe |
3 | Outils d'analyse statique | Test statique | Les développeurs |
4 | Outils de préparation des données de test | Analyse et conception, génération de données de test | Testeurs |
5 | Outils d'exécution de test | Mise en œuvre, exécution | Testeurs |
6 | Comparateurs de tests | Comparaison des résultats attendus et réels | Tous les membres de l'équipe |
sept | Outils de mesure de la couverture | Fournit une couverture structurelle | Les développeurs |
8 | Outils de test de performance | Suivi des performances, temps de réponse | Testeurs |
9 | Outils de planification et de suivi de projet | Pour la planification | Responsables de projet |
dix | Outils de gestion des incidents | Pour gérer les tests | Testeurs |
Où QTP s'intègre-t-il?
QTP est un outil de test fonctionnel, qui convient le mieux aux tests de régression des applications. QTP est un outil sous licence / commercial appartenant à HP, qui est l'un des outils les plus populaires disponibles sur le marché. Il compare le résultat réel et attendu et rapporte les résultats dans le résumé de l'exécution.
QTP - Histoire et évolution
HP Quick Test Professional appartenait à l'origine à Mercury Interactive et a été acquis par HP. Son nom d'origine était Astra Quick Test et plus tard nommé Quick Test Professional, mais la dernière version est connue sous le nom de Unified Functional Tester (UFT).
Historique des versions
Jetons maintenant un œil à l'historique des versions de QTP.
Versions | Délais |
---|---|
Astra Quick Test v1.0 à v5.5 - Mercury Interactive | Mai 1998 à août 2001 |
QuickTest Professional v6.5 à v9.0 - Mercury Interactive | 2003 à avril 2006 |
Hp-QuickTest Professional v9.1 à v11.0 - acquis et lancé par HP | Février 2007 à septembre 2010 |
Test fonctionnel HP-Unified v11.5 à v11.53 | 2012 à novembre 2013 |
Avantages
Le développement de tests automatisés à l'aide de VBScript ne nécessite pas un codeur hautement qualifié et est relativement facile par rapport à d'autres langages de programmation orientés objet.
Facile à utiliser, facilité de navigation, validation des résultats et génération de rapports.
Facilement intégré à l'outil de gestion des tests (Hp-Quality Center) qui facilite la planification et la surveillance.
Peut également être utilisé pour les tests d'applications mobiles.
Puisqu'il s'agit d'un produit HP, une assistance complète est fournie par HP et par ses forums pour résoudre les problèmes techniques.
Désavantages
Contrairement à Selenium, QTP fonctionne uniquement sous le système d'exploitation Windows.
Toutes les versions des navigateurs ne sont pas prises en charge et les testeurs doivent attendre que le correctif soit publié pour chacune des versions principales.
Cela dit, qu'il s'agit d'un outil commercial, le coût de la licence est très élevé.
Même si le temps de script est inférieur, le temps d'exécution est relativement plus élevé car il charge le CPU et la RAM.
Pour toute implémentation d'outil automatisé, voici les phases / étapes de celui-ci. Chacune des étapes correspond à une activité particulière et chaque phase a un résultat précis.
Test Automation Feasibility Analysis- La première étape consiste à vérifier si l'application peut être automatisée ou non. Toutes les applications ne peuvent pas être automatisées en raison de ses limites.
Appropriate Tool Selection- La prochaine étape la plus importante est la sélection des outils. Cela dépend de la technologie dans laquelle l'application est construite, de ses fonctionnalités et de son utilisation.
Evaluate the suitable framework- Lors de la sélection de l'outil, l'activité suivante consiste à sélectionner un cadre approprié. Il existe différents types de cadres et chaque cadre a sa propre signification. Nous aborderons les frameworks en détail plus loin dans ce tutoriel.
Build Proof of Concept- La preuve de concept (POC) est développée avec un scénario de bout en bout pour évaluer si l'outil peut prendre en charge l'automatisation de l'application. Elle est réalisée avec un scénario de bout en bout, qui garantit que les principales fonctionnalités peuvent être automatisées.
Develop Automation Framework- Après la construction du POC, le développement du framework est effectué, ce qui est une étape cruciale pour la réussite de tout projet d'automatisation de test. Le cadre doit être construit après une analyse diligente de la technologie utilisée par l'application et de ses principales caractéristiques.
Develop Test Script, Execute, and Analyze- Une fois le développement du script terminé, les scripts sont exécutés, les résultats sont analysés et les défauts sont consignés, le cas échéant. Les scripts de test sont généralement contrôlés par version.
QTP est un outil commercial et la version d'essai peut être téléchargée directement à partir du site HP. Seule la version actuelle, qui est Test fonctionnel unifié (11.5x), est disponible au téléchargement. Voici l'URL à partir de laquelle la version d'essai peut être téléchargée.
L'URL de téléchargement - QTP
Procédure d'installation
Step 1 - Cliquez sur le lien "Essais et démos" et sélectionnez "HP Unified Functional Testing 11.50 CC English SW E-Media Evaluation" comme indiqué ci-dessous -
Step 2- Après avoir sélectionné «HP Unified Functional Testing 11.50», l'assistant de téléchargement s'ouvre. Remplissez les informations personnelles et cliquez sur Suivant.
Step 3 - Lisez les «Conditions d'utilisation» et cliquez sur «SUIVANT».
Step 4- La fenêtre de téléchargement s'ouvre. Maintenant, cliquez sur le bouton "Télécharger".
Step 5- Le fichier téléchargé sera au format .RAR. Maintenant, vous devez décompresser l'archive et le contenu du dossier serait comme indiqué ci-dessous et exécuter Setup.exe.
Step 6 - Lors de l'exécution du fichier d'installation, pour installer, sélectionnez "Unified Functional Testing Set up" dans la liste comme indiqué ci-dessous -
Step 7 - Cliquez ensuite sur Suivant pour continuer.
Step 8- Dans la fenêtre de configuration personnalisée, sélectionnez les plugins nécessaires à votre automatisation, c'est-à-dire que vous devez sélectionner les plugins en fonction de la technologie de votre application testée. Par exemple, si votre application est basée sur .NET, vous devez vous assurer de sélectionner .NET.
Step 9- Après avoir sélectionné les plugins requis pour l'installation, cliquez sur Suivant. Une fois l'installation terminée, vous vous retrouverez avec une fenêtre de bouton Terminer.
Step 10- Une fois que vous avez terminé votre installation, la boîte de dialogue "Exigences d'installation supplémentaires" s'ouvre. Sélectionnez tout dans la liste autre que "Exécuter l'assistant d'installation de licence" et cliquez sur "EXÉCUTER". Nous n'avons PAS besoin de sélectionner "Exécuter l'assistant d'installation de licence" car nous installons la version d'essai, qui, par défaut, donne une licence pour 30 jours.
Step 11- Une fois les conditions d'installation supplémentaires terminées, une coche s'affiche, indiquant à son tour que les composants sont installés avec succès. Maintenant, cliquez sur Fermer.
Lancement de la page UFT et des compléments
Step 1 - Après l'installation, l'application peut être lancée à partir du menu Démarrer comme indiqué sur la figure.
Step 2- La page de licence apparaît. Vous pouvez cliquer sur Continuer car nous avons installé la licence d'essai.
Step 3 - La boîte de dialogue Compléments s'ouvre pour que l'utilisateur sélectionne les compléments requis.
Note - Ne chargez pas tous les compléments mais uniquement les compléments requis et cliquez sur OK.
Step 4 - Après avoir chargé les compléments requis, l'outil UFT 11.5 s'ouvre pour l'utilisateur et le premier aperçu des looks UFT, comme indiqué ci-dessous -
L'enregistrement d'un test correspond à l'enregistrement des actions utilisateur de l'application testée afin qu'UFT génère automatiquement les scripts qui peuvent être lus. L'enregistrement et la lecture peuvent nous donner une première impression de l'outil, qu'il puisse prendre en charge la technologie ou non, si les paramètres initiaux sont correctement effectués.
Les étapes d'enregistrement et de lecture sont les suivantes -
Step 1 - Cliquez sur "Nouveau" test de la page de démarrage comme indiqué ci-dessous -
Step 2- En cliquant sur "Nouveau" lien, une nouvelle fenêtre de test s'ouvre et l'utilisateur doit sélectionner le type de test. Sélectionnez "Test GUI", donnez un nom au test et l'emplacement où il doit être enregistré.
Step 3- Une fois qu'un nouveau test est créé, le nouvel écran de test s'ouvre comme indiqué ci-dessous. Maintenant, cliquez sur l'onglet "Action1", qui est créé avec 1 action par défaut.
Step 4 - Cliquez sur le menu "Enregistrer" et sélectionnez "Paramètres d'enregistrement et d'exécution" comme indiqué ci-dessous -
Step 5- La boîte de dialogue Paramètres d'enregistrement et d'exécution s'ouvre et en fonction du type d'application, vous pouvez sélectionner des applications Web, Java ou Windows. Par exemple, ici, nous enregistrerons une application Web (http://easycalculation.com/).
Step 6- Cliquez sur Enregistrer. Internet Explorer s'ouvre automatiquement avec l'adresse Webhttps://www.easycalculation.com/selon les paramètres. Cliquez sur le lien "Nombres" sous "Algèbre" et entrez un nombre et appuyez sur "Calculer". Une fois l'action terminée, cliquez sur le bouton "Arrêter" dans le panneau d'enregistrement. Vous remarquerez que le script est généré comme indiqué ci-dessous -
Step 7- Maintenant, lisez le script en cliquant sur le bouton de lecture. Le script est relu et le résultat est affiché.
Step 8 - La fenêtre de résultat est ouverte, par défaut, qui montre exactement l'horodatage des étapes d'exécution, de réussite et d'échec.
Importance de l'enregistrement et de la lecture
Il est utilisé comme méthode d'enquête préliminaire pour vérifier si UFT peut prendre en charge la technologie / l'application.
Utilisé pour créer un test d'une fonctionnalité de base d'une application ou d'une fonctionnalité qui ne nécessite pas de maintenance à long terme.
Il peut être utilisé pour enregistrer à la fois les mouvements de la souris et les entrées du clavier.
Modes d'enregistrement
Normal Recording - Il s'agit du mode d'enregistrement par défaut qui enregistre les objets et les opérations effectuées sur l'application testée.
Analog Recording - Cela enregistre non seulement les actions du clavier mais également les mouvements de la souris par rapport à l'écran ou à la fenêtre de l'application.
Low-Level Recording- Ceci enregistre les coordonnées exactes des objets indépendamment du fait que UFT reconnaisse l'objet ou NON. Il enregistre simplement les coordonnées, donc N'enregistre PAS les mouvements de la souris.
Insight Recording - UFT enregistre les opérations, en fonction de son apparence et non en fonction de ses propriétés natives.
Comment choisir les modes d'enregistrement
Après avoir cliqué sur le bouton Enregistrement, l'utilisateur peut choisir le mode d'enregistrement dans le volet d'enregistrement qui apparaît à l'écran, une fois l'enregistrement démarré. La sélection peut être faite à partir de n'importe lequel de ceux qui ont été discutés ci-dessus.
Vous verrez que le scénario suivant est enregistré dans tous les modes et la même action a été enregistrée dans diverses circonstances.
- Lancer IE - https://www.easycalculation.com/
- Cliquez sur "Nombres" sous "Algèbre"
- Cliquez sur le lien "Racine carrée"
- Entrez une valeur pour calculer la racine carrée. Disons 10
- Hit Calculer
Le script enregistré en mode d'enregistrement par défaut, analogique et bas niveau est indiqué ci-dessous -
' DEFAULT RECORDING MODE
Browser("Free Online Math Calculator").Page("Free Online Math
Calculator").Link("Numbers").Click
Browser("Free Online Math Calculator").Page("Numbers Calculator -
Math").Link("Square Root").Click
Browser("Free Online Math Calculator").Page("Square Root
Calculator").WebEdit("n").Set "10"
Browser("Free Online Math Calculator").Page("Square Root
Calculator").WebButton("calculate").Click
' ANALOG RECORDING MODE
Desktop.RunAnalog "Track1"
' LOW LEVEL RECORDING MODE
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click
235,395
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click
509,391
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click
780,631
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Type
"10"
Window("Windows Internet Explorer").WinObject("Internet Explorer_Server").Click
757,666
Les enregistrements utilisant le mode d'enregistrement Insight seront comme indiqué ci-dessous -
Référentiel d'objets
Object Repository est une collection d'objets et de propriétés avec lesquels QTP pourra reconnaître les objets et agir sur eux. Lorsqu'un utilisateur enregistre un test, les objets et ses propriétés sont capturés par défaut. Sans comprendre les objets et leurs propriétés, QTP ne pourra PAS lire les scripts.
Cliquez sur chacun des sujets suivants pour en savoir plus sur Object Repository et ses fonctionnalités associées.
Sr.No. | Description du sujet |
---|---|
1 | Object Spy et ses fonctionnalités Comprendre l'utilisation de l'espionnage d'objets et ses fonctionnalités associées. |
2 | Utilisation du référentiel d'objets Ajouter, éditer, supprimer des objets d'un référentiel d'objets et de ses fonctionnalités associées. |
3 | Types de référentiel d'objets Traite les objets partagés et le référentiel d'objets local et leur contexte en ce qui concerne les scripts. |
4 | Objets définis par l'utilisateur Traite les circonstances d'utilisation des objets définis par l'utilisateur. |
5 | Référentiel d'objets en XML Traite de la conversion des OR en XML et de l'utilisation du référentiel d'objets en XML. |
6 | Comparaison et fusion OU Des opérations telles que Compare OR ', Merge OR's pour travailler efficacement avec Object Repository. |
sept | Identificateurs ordinaux Circonstances où les identificateurs ordinaux sont utilisés et leurs avantages. |
8 | Objets enfants Utilisation d'objets enfants pour des scripts efficaces |
Actions aide les testeurs à diviser les scripts en groupes d'instructions QTP. Les actions sont similaires aux fonctions de VBScript; cependant, il existe quelques différences. Par défaut, QTP crée un test avec une action.
Actions | Les fonctions |
---|---|
L'action est une fonctionnalité intégrée de QTP. | Les fonctions VBScript sont prises en charge par VBScript et QTP. |
Les paramètres des actions sont transmis par valeur uniquement. | Les paramètres de fonction sont passés soit par valeur, soit par référence. |
Les actions ont l'extension .mts | Les fonctions sont enregistrées au format .vbs ou .qfl |
Les actions peuvent ou non être réutilisables. | Les fonctions sont toujours réutilisables. |
Les propriétés de l'action sont accessibles en cliquant avec le bouton droit de la souris sur la fenêtre de l'éditeur de script et en sélectionnant "Propriétés".
Les propriétés d'action contiennent les informations suivantes -
- Nom de l'action
- Location
- Drapeau réutilisable
- Paramètres d'entrée
- Paramètres de sortie
Types d'actions
Il existe trois types d'actions -
Non-reusable action - Une action qui ne peut être appelée que dans le test spécifique dans lequel elle a été conçue et qui ne peut être appelée qu'une seule fois.
Reusable action - Une action qui peut être appelée plusieurs fois, tout test dans lequel elle réside, et peut également être utilisée par tout autre test.
External Reusable action- C'est une action réutilisable stockée dans un autre test. Les actions externes sont en lecture seule dans le test d'appel, mais elles peuvent être utilisées localement avec la copie modifiable des informations de la table de données pour l'action externe.
Travailler avec des actions
Il existe trois options pour insérer une action. Cliquez sur chacun d'entre eux pour en savoir plus sur le type d'action sélectionné.
Sr.No. | Type d'action et description |
---|---|
1 | Insérer un appel à une nouvelle action Insère une nouvelle action à partir de l'action existante |
2 | Insérer un appel à une copie d'action Insère une copie d'une action existante |
3 | Insérer un appel à une action existante Insère un appel à une action réutilisable existante |
Un DataTable, similaire à Microsoft Excel, aide les testeurs à créer des scénarios de test basés sur les données qui peuvent être utilisés pour exécuter une action plusieurs fois. Il existe deux types de tables de données -
Local DataTable - Chaque action a sa propre table de données privée, également appelée table de données locale, qui est également accessible à travers les actions.
Global DataTable - Chaque test a une fiche de données globale accessible à travers les actions.
La fiche technique est accessible à partir de l'onglet «Données» de QTP comme indiqué ci-dessous -
Pour exécuter un scénario de test pour un certain nombre d'itérations spécifié, on peut définir les itérations de la table de données globale dans la boîte de dialogue Paramètres de test, accessible en utilisant Fichier → Paramètres → Exécuter (onglet) comme indiqué ci-dessous -
Exemple
Par exemple, si un utilisateur souhaite paramétrer "l'intérêt composé" de http://easycalculation.com/ accessible en utilisant http://easycalculation.com/compound-interest.php. Les paramètres peuvent être créés comme indiqué ci-dessous. La plupart des fonctionnalités d'Excel peuvent également être utilisées dans le tableau de données.
Opérations DataTable
Il existe trois types d'objets pour accéder à DataTable. Les opérations DataTable peuvent être bien comprises en parcourant ce qui suit -
Sr.No. | Type d'objet et description |
---|---|
1 | Méthodes de table de données Donne des informations détaillées sur les méthodes des tableaux de données. |
2 | Méthodes d'objet DTParameter Donne des informations détaillées sur les méthodes DTParameter. |
3 | Méthodes d'objet DTSheet Donne des informations détaillées sur les méthodes DTSheet. |
Les points de contrôle, comme son nom l'indique, font référence à un point de validation qui compare la valeur actuelle des propriétés spécifiées ou l'état actuel d'un objet avec la valeur attendue, qui peut être insérée à tout moment dans le script.
Types de points de contrôle
Sr.No. | Type et description |
---|---|
1 | Standard Checkpoint Vérifie les valeurs de propriété d'un objet dans l'application testée et prise en charge par tous les environnements de complément. |
2 | Bitmap Checkpoint Vérifie une zone de votre application sous forme de bitmap |
3 | File Content Checkpoint Vérifie le texte dans un fichier généré ou accédé dynamiquement tel que .txt, .pdf |
4 | Table Checkpoint Vérifie les informations dans une table. Tous les environnements ne sont pas pris en charge. |
5 | Text Checkpoint Vérifiez si le texte affiché dans une zone définie dans une application Windows, selon des critères spécifiés. |
6 | Text Area Checkpoint Vérifie si la chaîne de texte est affichée dans une zone définie dans une application Windows, selon des critères spécifiés. |
sept | Accessibility Checkpoint Vérifie la page et signale les zones du site Web qui peuvent ne pas être conformes aux directives d'accessibilité du contenu Web du World Wide Web Consortium (W3C) |
8 | Page Checkpoint Vérifie les caractéristiques d'une page Web. Il peut également vérifier les liens rompus. |
9 | Database Checkpoint Vérifie le contenu d'une base de données accessible par l'application testée. |
dix | XML Checkpoint Vérifie le contenu des documents .xml ou des documents .xml dans les pages Web et les cadres. |
Insertion de CheckPoint
Lorsque l'utilisateur souhaite insérer un point de contrôle, il faut s'assurer que la plupart des points de contrôle ne sont pris en charge que pendant les sessions d'enregistrement. Une fois que l'utilisateur arrête l'enregistrement, les points de contrôle ne sont pas activés.
Vous trouverez ci-dessous le menu des points de contrôle, lorsque l'utilisateur n'est PAS en mode d'enregistrement.
Vous trouverez ci-dessous le menu des points de contrôle, lorsque l'utilisateur est en mode d'enregistrement.
Exemple
Les points de contrôle sont ajoutés pour l'application testée - "http://easycalculation.com/"
' 1. Inserted Standard Checkpoint
Status = Browser("Math Calculator").Page("Math
Calculator").Link("Numbers").Check CheckPoint("Numbers")
If Status Then
print "Checkpoint Passed"
Else
Print "Checkpoint Failed"
End if
' 2. Inserted BitMap Checkpoint
imgchkpoint = Browser("Math Calculator").Page("Math
Calculator").Image("French").Check CheckPoint("French")
If imgchkpoint Then
print "Checkpoint Passed"
Else
Print "Checkpoint Failed"
End if
Affichage des propriétés des points de contrôle
Après l'insertion, au cas où un testeur souhaite modifier les valeurs, nous pouvons le faire en cliquant avec le bouton droit de la souris sur le mot-clé 'point de contrôle' du script et en naviguant vers "Propriétés du point de contrôle" comme indiqué ci-dessous
Vous pouvez également localiser les mêmes points de contrôle dans le référentiel d'objets, comme illustré ci-dessous. Il montre exactement quel type de point de contrôle est utilisé et quelles sont les valeurs attendues et les valeurs de délai d'expiration.
Le point de synchronisation est l'interface temporelle entre l'outil et l'application sous test. Le point de synchronisation est une fonction permettant de spécifier le délai entre deux étapes du script de test.
Par exemple, cliquer sur un lien peut charger la page pendant 1 seconde, parfois 5 secondes ou même 10 secondes pour la charger complètement. Cela dépend de divers facteurs tels que le temps de réponse du serveur d'applications, la bande passante du réseau et les capacités du système client.
Si l'heure varie, le script échouera, à moins que le testeur ne gère intelligemment ces différences de temps.
Façons d'insérer un point de synchronisation
- WaitProperty
- Exist
- Wait
- Sync (uniquement pour les applications Web)
- Insertion de points de synchronisation intégrés QTP.
Disons que nous devons insérer un point de synchronisation entre un clic sur le lien "nombres" et un clic sur la calculatrice "intérêt simple" dans " www.easycalculation.com ". Nous allons maintenant examiner les cinq façons d'insérer un point de synchronisation pour le scénario ci-dessus.
Méthode 1 - WaitProperty
WaitProperty est une méthode qui prend le nom de la propriété, la valeur et la valeur du délai d'expiration comme entrée pour effectuer la synchronisation. Il s'agit d'une attente dynamique et, par conséquent, cette option est encouragée.
' Method 1 - WaitProperty with 25 seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click
obj.Link("Simple Interest").WaitProperty "text", "Simple Interest",25000
obj.Link("Simple Interest").Click
Méthode 2 - Existe
Exist est une méthode qui prend la valeur Timeout comme entrée pour effectuer la synchronisation. Encore une fois, il s'agit d'une attente dynamique et, par conséquent, cette option est encouragée.
' Method 2 : Exist Timeout - 30 Seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click
If obj.Link("Simple Interest").Exist(30) Then
obj.Link("Simple Interest").Click
Else
Print "Link NOT Available"
End IF
Méthode 3 - Attendre
Wait est un point de synchronisation codé en dur, qui attend indépendamment de l'événement qui s'est produit ou NON. Par conséquent, l'utilisation de Wait est déconseillée et peut être utilisée pour un temps d'attente plus court, par exemple 1 ou 2 secondes.
' Method 3 : Wait Timeout - 30 Seconds
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click
wait(30)
Browser("Math Calculator").Page("Math Calculator").Link("Simple Interest").Click
Méthode 4 - Méthode de synchronisation
La méthode de synchronisation ne peut être utilisée que pour les applications Web où il y a toujours un décalage entre les chargements de page.
' Method 4 :
Dim obj
Set obj = Browser("Math Calculator").Page("Math Calculator")
obj.Link("Numbers").Click
Browser("Math Calculator").Sync
Browser("Math Calculator").Page("Math Calculator").Link("Simple Interest").Click
Méthode 5 - Insertion de points de synchronisation intégrés QTP
Step 1- Passez en mode enregistrement. Cette option serait désactivée si l'utilisateur n'est PAS en mode enregistrement.
Step 2 - Allez dans "Conception" → "Point de synchronisation".
Step 3- Nous devons sélectionner l'objet que nous voulons être le point de synchronisation. Après avoir sélectionné l'objet, la fenêtre d'objet s'ouvre comme indiqué ci-dessous -
Step 4- Cliquez sur OK; la fenêtre "Ajouter une synchronisation" s'ouvre. Sélectionnez la valeur Propriété, Valeur et Délai d'expiration et cliquez sur OK comme indiqué ci-dessous -
Step 5 - Le script serait généré comme indiqué ci-dessous, qui est le même que celui de WaitProperty (Méthode 1) dont nous avions déjà parlé -
Browser("Math Calculator").Page("Math Calculator").Link("Numbers").Click
Browser("Math Calculator").Page("Math Calculator").Link("Simple
Interest").WaitProperty "text", "Simple Interest", 10000
Synchronisation par défaut
Lorsque l'utilisateur n'a utilisé aucune des méthodes de synchronisation ci-dessus, QTP dispose toujours d'un délai de synchronisation d'objet intégré qui peut être ajusté par l'utilisateur.
Accédez à "Fichier" >> "Paramètres" >> Onglet Exécuter >> Délai de synchronisation d'objet comme indiqué ci-dessous.
Parfois, QTP est incapable de trouver un objet qui correspond à la description de l'objet reconnu ou il peut trouver plusieurs objets qui correspondent à la description, puis QTP ignore la description reconnue et utilise le mécanisme d'identification intelligente pour reconnaître l'objet.
L'identification intelligente de QTP utilise deux types de propriétés -
Base Filter Properties - Les propriétés de base d'une classe d'objets de test particulière dont les valeurs ne peuvent pas être modifiées sans changer l'essence de l'objet d'origine.
Optional Filter Properties - D'autres propriétés aident également à identifier les objets d'une classe particulière dont les propriétés sont peu susceptibles de changer souvent mais peuvent être ignorées si elles ne sont plus applicables.
Activation de l'identification intelligente pour un objet
Step 1- Accédez à "Outils" → "Identification d'objet". La boîte de dialogue Identification d'objet s'ouvre.
Step 2 - Choisissez l'environnement, la classe d'objet et activez "Activer l'identification intelligente" comme indiqué ci-dessous -
Step 3 - Cliquez sur Configurer et choisissez la base et les propriétés de filtre facultatives.
Step 4- Ajouter des propriétés dans les propriétés de base en dehors de celle par défaut et également ajouter / supprimer des propriétés de filtre facultatives. Veuillez noter que les mêmes propriétés ne peuvent pas faire partie à la fois des propriétés obligatoires et des propriétés fonctionnelles et cliquez sur «OK».
Step 5- Vérifiez si l'identification intelligente est activée après l'ajout d'un objet de ce type dans le référentiel d'objets. L'identification intelligente est définie sur TRUE. Nous pouvons également le rendre faux au cas où nous ne voudrions pas activer l'identification intelligente.
Step 6 - Nous pouvons même désactiver un niveau de test en appliquant au niveau du script de test sous "Paramètres" du menu "Fichier" comme indiqué ci-dessous -
Step 7 - Si l'identification intelligente est désactivée conformément à l'étape 6, elle n'appliquera l'identification intelligente pour aucun objet pendant l'exécution du script.
Step 8 - Dans le cas où les objets sont ajoutés avec l'identification intelligente désactivée, QTP n'utilisera pas l'identification intelligente pour la reconnaissance à l'avenir, même si nous l'avons activée plus tard.
Le débogage, dans le contexte des tests d'automatisation, est un processus systématique de repérage et de résolution des problèmes de codage dans le script d'automatisation afin que le script soit plus robuste et puisse repérer les défauts de l'application.
Il existe différentes manières d'effectuer le débogage à l'aide de points d'arrêt dans QTP. Les points de rupture peuvent être insérés simplement en appuyant sur "F9" ou en utilisant l'option de menu "Exécuter" → "Insérer / Supprimer un point de rupture".
Après avoir inséré le point de rupture, le point "de couleur rouge" et la ligne seront mis en évidence en ROUGE comme indiqué ci-dessous -
Méthode | Raccourci | La description |
---|---|---|
Entrer dans | F11 | Utilisé pour exécuter chaque étape. Entre dans la fonction / action et s'exécute ligne par ligne. Il s'arrête sur chaque ligne après l'exécution. |
Enjamber | F10 | Utilisé pour passer au-dessus de la fonction. Step Over exécute uniquement l'étape en cours dans le document actif. |
Sors | Maj + F11 | Après être entré dans la fonction, vous pouvez utiliser la commande Step Out. Step Out continue l'exécution jusqu'à la fin de la fonction, puis suspend la session d'exécution à la ligne suivante. |
Options du point de rupture
Diverses options dans Break Point sont accessibles en naviguant dans le menu «Exécuter».
Sr.No. | Raccourci et description |
---|---|
1 | F9 Insérer / supprimer un point d'arrêt |
2 | Ctrl+F9 Activer / désactiver BreakPoint |
3 | Ctrl+Shift+F9 Effacer tout BreakPoint |
4 | Use Only Menu Activer / désactiver tous les points d'arrêt |
Volet de débogage
Voici les volets de la fenêtre de débogage -
Output - Cet onglet affiche toutes les sorties des instructions d'impression.
Watch - Cet onglet affiche la sortie booléenne de l'expression donnée.
LocalVariables - Cet onglet affiche la sortie des variables locales.
Exemple
Le volet de surveillance affiche l'expression de sortie comme indiqué ci-dessous -
Le volet Variables locales affiche les valeurs détenues par les variables locales comme indiqué ci-dessous -
Il existe différentes manières de gérer les erreurs dans QTP. Il existe trois types d'erreurs possibles que l'on rencontrerait en travaillant avec QTP. Ils sont -
- Erreurs de syntaxe
- Erreurs logiques
- Erreurs d'exécution
Types d'erreur
Erreurs de syntaxe
Les erreurs de syntaxe sont les fautes de frappe ou un morceau de code qui ne confirme pas avec la grammaire du langage VBscripting. Les erreurs de syntaxe se produisent au moment de la compilation du code et ne peuvent pas être exécutées tant que les erreurs ne sont pas corrigées.
Pour vérifier la syntaxe, utilisez le raccourci clavier Ctrl + F7 et le résultat s'affiche comme indiqué ci-dessous. Si la fenêtre n'est pas affichée, on peut naviguer vers "Affichage" → "Erreurs".
Erreurs logiques
Si le script est syntaxiquement correct mais qu'il produit des résultats inattendus, il s'agit d'une erreur logique. Une erreur logique n'interrompt généralement pas l'exécution mais produit des résultats incorrects. Des erreurs logiques peuvent survenir pour diverses raisons, des hypothèses erronées ou des malentendus de l'exigence et parfois des logiques de programme incorrectes (en utilisant do-while au lieu de do-Until) ou des boucles infinies.
L'un des moyens de détecter une erreur logique consiste à effectuer des examens par les pairs et également à vérifier le fichier de sortie / fichier de résultats QTP pour s'assurer que l'outil a fonctionné comme il était censé le faire.
Erreurs d'exécution
Comme son nom l'indique, ce type d'erreur se produit pendant l'exécution. La raison de ce type d'erreurs est que le script essayant d'effectuer quelque chose est incapable de le faire et le script s'arrête généralement, car il est incapable de continuer l'exécution. Les exemples classiques d'erreurs d'exécution sont -
- Fichier NON trouvé mais le script tente de lire le fichier
- Objet NON trouvé mais le script essaie d'agir sur cet objet particulier
- Diviser un nombre par zéro
- Index du tableau hors limites lors de l'accès aux éléments du tableau
Gestion des erreurs d'exécution
Il existe différentes manières de gérer les erreurs dans le code.
1. Using Test Settings- La gestion des erreurs peut être définie dans les paramètres de test en accédant à l'onglet "Fichier" >> "Paramètres" >> "Exécuter" comme indiqué ci-dessous. Nous pouvons sélectionner l'un des paramètres spécifiés et cliquer sur "OK".
2. Using On Error Statement - L'instruction «On Error» est utilisée pour informer le moteur VBScript des intentions de gérer les erreurs d'exécution par un testeur, plutôt que de permettre au moteur VBScript d'afficher des messages d'erreur qui ne sont pas conviviaux.
On Error Resume Next - On Error Resume Next informe le moteur VBScript de traiter l'exécution de la ligne de code suivante lorsqu'une erreur est rencontrée.
On error Goto 0 - Cela aide les testeurs à désactiver la gestion des erreurs.
3. Using Err Object - L'objet d'erreur est un objet intégré dans VBScript qui capture le numéro d'erreur d'exécution et la description de l'erreur avec lesquels nous pouvons facilement déboguer le code.
Err.Number- La propriété Number renvoie ou définit une valeur numérique spécifiant une erreur. Si la valeur Err.Number est 0, aucune erreur ne s'est produite.
Err.Description - La propriété Description renvoie ou définit une brève description d'une erreur.
Err.Clear - La méthode Clear réinitialise l'objet Err et efface toutes les valeurs précédentes qui lui sont associées.
Exemple
'Call the function to Add two Numbers Call Addition(num1,num2)
Function Addition(a,b)
On error resume next
If NOT IsNumeric(a) or IsNumeric(b) Then
Print "Error number is " & err.number & " and description is :
" & err.description
Err.Clear
Exit Function
End If
Addition = a+b
'disables error handling
On Error Goto 0
End function
4. Using Exit Statement- Les instructions de sortie peuvent être utilisées avec l'objet Err pour quitter un test, une action ou une itération en fonction de la valeur Err.Number. Voyons chacune de ces instructions Exit en détail.
ExitTest - Quitte l'ensemble du test QTP, quels que soient les paramètres d'itération au moment de l'exécution.
ExitAction - Quitte l'action en cours.
ExitActionIteration - Quitte l'itération actuelle de l'action.
ExitTestIteration - Quitte l'itération actuelle du test QTP et passe à l'itération suivante.
5. Recovery Scenarios - En cas d'erreur, des scénarios de récupération sont déclenchés en fonction de certaines conditions et sont traités en détail dans un chapitre séparé.
6. Reporter Object- L'objet Reporter nous aide à signaler un événement aux résultats de l'exécution. Cela nous aide à identifier si l'action / l'étape concernée est réussite / échec.
'Syntax: Reporter.ReportEventEventStatus, ReportStepName, Details,
[ImageFilePath]
'Example
Reporter.ReportEvent micFail, "Login", "User is unable to Login."
Scénarios de récupération
Lors de l'exécution des scripts QTP, nous pourrions obtenir des erreurs inattendues. Afin de récupérer les tests et de continuer à exécuter le reste du script à partir de ces erreurs inattendues, des scénarios de récupération sont utilisés. Le gestionnaire de scénario de récupération est accessible en accédant à "Ressources" → Gestionnaire de scénario de récupération comme indiqué ci-dessous -
Étapes pour créer un scénario de récupération
Step 1- Cliquez sur le bouton "Nouveau" scénario de récupération; l'assistant de scénario de récupération s'ouvre comme indiqué ci-dessous -
Step 2- Choisissez l'événement déclencheur. Cela correspond à un événement, qui peut survenir dans l'un des quatre événements suivants -
- Fenêtre pop-up
- État de l'objet
- Erreur d'exécution du test
- Crash d'application
Step 3- La fenêtre des opérations de récupération s'ouvre. L'opération de récupération peut effectuer l'une des opérations suivantes, comme indiqué dans la capture d'écran ci-dessous -
Step 4 - Après avoir spécifié l'opération de récupération appropriée, nous devons également spécifier l'opération de post-récupération, comme indiqué ci-dessous -
Step 5 - Après avoir spécifié l'opération de post-récupération, le scénario de récupération doit être nommé et ajouté au test afin de pouvoir être activé.
Step 6 - La création du scénario de récupération est terminée et doit être mappée au test en cours en cochant l'option "Ajouter un scénario au test en cours" et en cliquant sur "Terminer".
Step 7 - Le scénario de récupération ajouté sera comme indiqué ci-dessous et cliquez sur le bouton «Fermer» pour continuer.
Step 8- Après avoir cliqué sur le bouton Fermer, QTP invite l'utilisateur à enregistrer le scénario de récupération créé. Il sera enregistré avec l'extension .qrs et l'assistant se fermera.
Vérification
Le scénario de récupération créé devrait faire partie du test maintenant et peut être vérifié en accédant à l'onglet «Fichier» → «Paramètres» → «Récupération».
Les variables d'environnement QTP sont des types spéciaux de variables auxquelles toutes les actions, bibliothèques de fonctions et scénarios de récupération peuvent accéder. Il existe des variables d'environnement intégrées pour Windows qui sont disponibles pour toutes les applications exécutées sur ce système particulier, mais les variables d'environnement QTP ne sont disponibles que pour ce script de test particulier lors de l'exécution.
Types de variables d'environnement
Built-in Environment Variables- fournit une gamme de paramètres d'environnement qui peuvent fournir des informations telles que le nom du test, le nom de l'action, le chemin du test, le nom d'hôte local, le nom du système d'exploitation, le type et sa version. Les noms des variables d'environnement sont accessibles en accédant à "Fichier" → "Paramètres de test" → onglet "Environnement".
User defined Internal- Les variables définies par l'utilisateur peuvent être enregistrées en sélectionnant "Défini par l'utilisateur" dans la fenêtre de l'onglet Environnement. Le bouton "+" est cliqué pour entrer le nom et la valeur du paramètre comme indiqué ci-dessous -
User Defined External- Les variables définies par l'utilisateur peuvent être stockées dans un fichier externe en tant que fichier .xml et peuvent être chargées dans le test comme indiqué dans la figure ci-dessous. Il peut également être chargé dynamiquement pendant l'exécution comme expliqué ci-dessous dans l'un des exemples.
Variables d'environnement - Méthodes prises en charge
1. ExternalFileName Property- Renvoie le nom du fichier de variable d'environnement externe chargé spécifié dans l'onglet Environnement de la boîte de dialogue Paramètres de test. Si aucun fichier de variable d'environnement externe n'est chargé, cette propriété renvoie une chaîne vide.
x = Environment.ExternalFileName
print x
2. LoadFromFile Method- Charge le fichier de variables d'environnement spécifié (.xml) dynamiquement pendant l'exécution. Lorsque vous utilisez cette méthode, les variables d'environnement n'ont pas besoin d'être ajoutées manuellement dans l'onglet Environnement.
Environment.LoadFromFile "D:\config.xml"
b = Environment.Value("Browser")
print b
3. Value Property- Récupère la valeur des variables d'environnement. Nous pouvons également définir la valeur des variables d'environnement internes définies par l'utilisateur à l'aide de cette propriété.
' Get the Value of the InBuilt Environment Variables
a = Environment.Value("OS")
print a
b = Environment.Value("ActionName")
print b
'Loaded from External File
Environment.LoadFromFile "D:\config.xml"
c = Environment.Value("Browser")
print c
Afin de modulariser le script, des fichiers de bibliothèque sont ajoutés au script QTP. Il contient des déclarations de variables, des fonctions, des classes, etc. Ils permettent une réutilisation qui peut être partagée entre les scripts de test. Ils sont enregistrés avec une extension .vbs ou .qfl
Un nouveau fichier de bibliothèque peut être créé en accédant à "Fichier" >> "Bibliothèque de fonctions".
Association de bibliothèques de fonctions
Method 1- En utilisant l'option "Fichier"> "Paramètres"> Ressources> Associer la bibliothèque de fonctions. Cliquez sur le bouton "+" pour ajouter un fichier de bibliothèque de fonctions et ajoutez-le en utilisant le chemin réel ou le chemin relatif comme indiqué ci-dessous -
Method 2 - Utilisation de la méthode ExecuteFile.
'Syntax : ExecuteFile(Filepath)
ExecuteFile "C:\lib1.vbs"
ExecuteFile "C:\lib2.vbs"
Method 3 - Utilisation de la méthode LoadFunctionLibrary.
'Syntax : LoadFunctionLibrary(Filepath)
LoadFunctionLibrary "C:\lib1.vbs"
LoadFunctionLibrary "C:\lib2.vbs"
Method 4- Modèle d'objet d'automatisation (AOM) - Il s'agit d'un mécanisme à l'aide duquel nous pouvons contrôler diverses opérations QTP en dehors de QTP. En utilisant AOM, nous pouvons lancer QTP, ouvrir le test, associer des bibliothèques de fonctions, etc. L'AOM sera discuté en détail dans les chapitres suivants.
'Launch QTP
Set objQTP = CreateObject("QuickTest.Application")
objQTP.Launch
objQTP.Visible = True
'Open the test
objQTP.Open "D:\GUITest2", False, False
Set objLib = objQTP.Test.Settings.Resources.Libraries
'Associate Function Library if NOT associated already.
If objLib.Find("C:\lib1.vbs") = -1 Then
objLib.Add "C:\lib1.vbs", 1
End
Résultats de test
La fenêtre Résultats du test nous donne suffisamment d'informations pour afficher les étapes réussies, échouées, etc. La fenêtre Résultats s'ouvre automatiquement après l'exécution du test (selon les paramètres par défaut). Les informations suivantes s'affichent -
- Étapes franchies
- Les étapes ont échoué
- Paramètres d'environnement
- Statistiques graphiques
Opérations effectuées dans les résultats de test
Conversion des résultats en HTML
Dans la fenêtre du visualiseur de résultats, accédez à "Fichier" → "Exporter vers un fichier". La boîte de dialogue Exporter les résultats de l'analyse s'ouvre comme indiqué ci-dessous -
Nous pouvons choisir le type de rapport à exporter. Cela peut être des résultats courts, des résultats détaillés ou même, nous pouvons sélectionner des nœuds. Après avoir sélectionné le nom de fichier et exporté, le fichier est enregistré en tant que fichier .HTML
Filtrer les résultats
Les résultats peuvent être filtrés en fonction de l'état, du type de nœud et des itérations. Il est accessible en utilisant le bouton Filtrer dans la "Fenêtre des résultats des tests".
Relever les défauts
Les défauts peuvent être enregistrés dans QC directement à partir du volet de la fenêtre des résultats de test en accédant à "Outils" → "Ajouter un défaut" qui ouvre la connexion à ALM comme indiqué ci-dessous -
Résultats de test
La fenêtre de résultats de test automatique peut être configurée sous "Outils" → "Options" → Onglet "Exécuter les sessions". Nous pouvons le désactiver, si nécessaire, et également activer "Exporter automatiquement les résultats à la fin de la session".
La capture d'écran ou le film peut être enregistré en fonction des paramètres. Le même peut être configuré sous "Outils" → "Options" → onglet "Capture d'écran". Nous pouvons enregistrer la capture d'écran ou les films en fonction des trois conditions suivantes -
- Pour les erreurs
- Always
- Pour les erreurs et les avertissements
Il existe différents objets GUI, avec lesquels QTP interagit, pendant l'exécution du script. Par conséquent, il est important de connaître les méthodes de base des objets clés de l'interface graphique à l'aide desquels nous pourrons travailler efficacement.
Travailler avec la zone de texte
Voici les méthodes à l'aide desquelles nous accédons à la zone de texte pendant l'exécution -
Set - Aide le testeur à définir des valeurs dans la zone de texte
Click - Clique sur la zone de texte
SetSecure - Utilisé pour définir le texte dans les boîtes de mot de passe en toute sécurité
WaitProperty - Attend que la valeur de la propriété devienne vraie
Exist - Vérifie l'existence de la zone de texte
GetROProperty("text") - Obtient la valeur de la zone de texte
GetROProperty("Visible") - Renvoie une valeur booléenne si visible
Exemple
Browser("Math Calculator").Sync
Set Obj = Browser("Math Calculator").Page("SQR Calc").WebEdit("n")
'Clicks on the Text Box
Obj.Click
'Verify if the Object Exist - Returns Boolean value
a = obj.Exist
print a
'Set the value
obj.Set "10000" : wait(2)
'Get the Runtime Object Property - Value of the Text Box
val = obj.GetROProperty("value")
print val
'Get the Run Time Object Property - Visiblility - Returns Boolean Value
x = Obj.GetROProperty("visible")
print x
Utilisation de la case à cocher
Voici quelques-unes des principales méthodes avec lesquelles on peut travailler avec Check Box -
Set - Aide le testeur à définir la valeur de la case à cocher «ON» ou «OFF»
Click- Clique sur la case à cocher. Vérifie même ON ou OFF mais l'utilisateur ne sera pas sûr de l'état
WaitProperty - Attend que la valeur de la propriété devienne vraie
Exist - Vérifie l'existence de la case à cocher
GetROProperty("name") - Obtient le nom de la case à cocher
GetROProperty("Visible") - Renvoie une valeur booléenne si visible
Exemple
'To Check the Check Box
Set Obj = Browser("Calculator").Page("Gmail").WebCheckBox("PersistentCookie")
Obj.Set "ON"
'To UnCheck the Check Box
Obj.Set "OFF"
'Verifies the Existance of the Check box and returns Boolean Value
val = Obj.Exist
print val
'Fetches the Name of the CheckBox
a = Obj.GetROProperty("name")
print a
'Verifies the visible property and returns the boolean value.
x = Obj.GetROProperty("visible")
print x
Travailler avec le bouton radio
Voici quelques-unes des méthodes clés avec lesquelles on peut travailler avec le bouton radio -
Select(RadioButtonName) - Aide le testeur à régler le boîtier radio sur "ON"
Click- Clique sur le bouton radio. Même bouton radio activé ou désactivé mais le testeur ne peut pas obtenir l'état
WaitProperty - Attend que la valeur de la propriété devienne vraie
Exist - Vérifie l'existence du bouton radio
GetROProperty("name") - Obtient le nom du bouton radio
GetROProperty("Visible") - Renvoie une valeur booléenne si visible
Exemple
'Select the Radio Button by name "YES"
Set Obj = Browser("Calculator").Page("Forms").WebRadioGroup("group1")
Obj.Select("Yes")
'Verifies the Existance of the Radio Button and returns Boolean Value
val = Obj.Exist
print val
'Returns the Outerhtml of the Radio Button
txt = Obj.GetROProperty("outerhtml")
print text
'Returns the boolean value if Radio button is Visible.
vis = Obj.GetROProperty("visible")
print vis
Utilisation de la zone de liste déroulante
Voici quelques-unes des méthodes clés avec lesquelles on peut travailler avec Combo Box -
Select(Value) - Aide le testeur à sélectionner la valeur de la ComboBox
Click - Clique sur l'objet
WaitProperty - Attend que la valeur de la propriété devienne vraie
Exist - Vérifie l'existence de la Combo Box
GetROProperty("Text") - Obtient la valeur sélectionnée de la zone de liste déroulante
GetROProperty("all items") - Renvoie tous les éléments de la liste déroulante
GetROProperty("items count") - Renvoie le nombre d'éléments dans la liste déroulante
Exemple
'Get the List of all the Items from the ComboBox
Set ObjList = Browser("Math Calculator").Page("Statistics").WebList("class")
x = ObjList.GetROProperty("all items")
print x
'Get the Number of Items from the Combo Box
y = ObjList.GetROProperty("items count")
print y
'Get the text value of the Selected Item
z = ObjList.GetROProperty("text")
print z
Travailler avec des boutons
Voici quelques-unes des méthodes clés avec lesquelles on peut travailler avec les boutons -
Click - Clique sur le bouton
WaitProperty - Attend que la valeur de la propriété devienne vraie
Exist - Vérifie l'existence du bouton
GetROProperty("Name") - Obtient le nom du bouton
GetROProperty("Disabled") - Renvoie une valeur booléenne si activée / désactivée
Exemple
'To Perform a Click on the Button
Set obj_Button = Browser("Math Calculator").Page("SQR").WebButton("Calc")
obj_Button.Click
'To Perform a Middle Click on the Button
obj_Button.MiddleClick
'To check if the button is enabled or disabled.Returns Boolean Value
x = obj_Button.GetROProperty("disabled")
print x
'To fetch the Name of the Button
y = obj_Button.GetROProperty("name")
print y
Travailler avec webTables
Dans l'application Web d'aujourd'hui, les webTables sont devenus très courants et les testeurs doivent comprendre comment fonctionnent les WebTables et comment effectuer une action sur les webTables. Cette rubrique vous aidera à travailler efficacement avec les webTables.
Sr.No. | Déclaration et description |
---|---|
1 | if statement Un if instruction se compose d'une expression booléenne suivie d'une ou plusieurs instructions. |
2 | if...else statement Un if elseinstruction se compose d'une expression booléenne suivie d'une ou plusieurs instructions. Si la condition est vraie. Les déclarations sousifles déclarations sont exécutées. Si la condition est fausse.Else une partie du script est exécutée |
3 | if..elseif...else statement Une instruction if suivie d'un ou plusieurs Elseif instructions, qui se composent d'expressions booléennes, puis suivies d'une option else statement, qui s'exécute lorsque toute la condition devient fausse. |
4 | nested if statements Un si ou elseif déclaration dans un autre if ou elseif déclaration (s). |
5 | switch statement UNE switch L'instruction permet à une variable d'être testée pour également une liste de valeurs. |
html id - Si la table a une balise d'identification, il est préférable d'utiliser cette propriété.
innerText - En-tête du tableau.
sourceIndex - Récupère l'index source de la table
ChildItemCount - Obtient le nombre de ChildItems présents dans la ligne spécifiée
RowCount - Obtient le nombre de lignes dans le tableau
ColumnCount - Obtient le nombre de colonnes dans le tableau
GetcellData - Obtient la valeur de la cellule en fonction de la colonne et de l'index de ligne
Exemple
Browser("Tutorials Point").Sync
' WebTable
Obj = Browser("Tutorials Point").Page("VBScript Decisions").WebTable("Statement")
' Fetch RowCount
x = Obj.RowCount
print x
' Fetch ColumnCount
y = Obj.ColumnCount(1)
print y
' Print the Cell Data of the Table
For i = 1 To x Step 1
For j = 1 To y Step 1
z = Obj.GetCellData(i,j)
print "Row ID : " & i & " Column ID : " & j & " Value : " & z
Next
Next
'Fetch the Child Item count of Type Link in a particular Cell
z = Obj.ChildItemCount(2,1,"Link")
print z
Que sont les objets virtuels?
Parfois, une application testée peut contenir un objet de fenêtre standard mais n'est pas reconnue par QTP. Dans ces circonstances, les objets peuvent être définis comme des objets virtuels (VO) de type bouton, lien, etc. afin que les actions de l'utilisateur puissent être simulées sur les objets virtuels pendant l'exécution.
Exemple
Disons que nous automatisons un scénario dans Microsoft Word. J'ai activé l'application MS Word et je clique sur n'importe quelle icône du ruban. Par exemple, sur le ruban, l'utilisateur clique sur l'onglet Insertion, puis l'utilisateur clique sur le bouton «Image». Un bouton est reconnu comme WinObject; par conséquent, l'importance des objets virtuels est prononcée.
Window("Microsoft Word").WinObject("Ribbon").Click 145,45
Window("Microsoft Word").WinObject("Ribbon").WinObject("Picture...").Click
170,104
Créer un objet virtuel
Step 1 - Dans de tels scénarios, des objets virtuels sont créés à l'aide du gestionnaire d'objets virtuels ou d'un nouvel objet virtuel à partir de "Outils" >> "Objet virtuel" >> "Nouvel objet virtuel" et cliquez sur le bouton "Suivant".
Step 2 - Mappez l'objet avec le type de classe et cliquez sur "Suivant".
Step 3- Cliquez sur le bouton "Marquer l'objet". Un curseur en croix apparaîtra et marque l'objet que vous souhaitez mapper et cliquez sur "Suivant".
Step 4 - Sélectionnez le parent de l'objet virtuel et cliquez sur "Suivant".
Step 5 - Nommez la collection dans laquelle vous souhaitez stocker l'objet virtuel et cliquez sur «Terminer».
Gestionnaire d'objets virtuels
Virtual Object Manager gère les collections d'objets virtuels. Les testeurs peuvent ajouter ou supprimer les objets virtuels à partir du gestionnaire d'objets virtuels.
Navigation vers Virtual Object Manager: "Outils" >> "Virtual Object Manager" comme indiqué ci-dessous -
Utilisation d'objets virtuels
Après avoir créé les objets virtuels, l'objet créé peut être utilisé comme indiqué ci-dessous -
Window("Microsoft Word").WinObject("Ribbon").VirtualButton("button").Click
Limitations des objets virtuels
QTP ne prend pas en charge les objets virtuels pour l'enregistrement analogique ou de bas niveau.
Les points de contrôle ne peuvent pas être ajoutés sur les objets virtuels.
Les objets virtuels ne sont pas contrôlés par le référentiel d'objets.
Bien que nous mappions un objet à une classe particulière (bouton ou liste), toutes les méthodes des objets natifs ne sont pas prises en charge par les objets virtuels.
Object Spy ne peut pas être utilisé sur un objet virtuel.
L'exécution du test échouera si la résolution de l'écran change à mesure que les coordonnées changent.
La fenêtre d'application doit être de la même taille d'écran pour que les objets virtuels soient correctement capturés.
En tant que tel, QTP ne fournit aucune prise en charge intégrée pour se connecter à la base de données, mais en utilisant VBScript, les testeurs pourront se connecter et interagir avec des bases de données à l'aide d'objets ADODB.
ADODB a 4 propriétés ou méthodes avec lesquelles nous pourrons travailler avec les bases de données. Ils sont -
ADODB.Connection - Utilisé pour établir une connexion à la base de données
ADODB.Command - Utilisé pour exécuter une commande SQL (requêtes ou procédures stockées)
ADODB.Fields - Utilisé pour récupérer une colonne particulière d'un jeu d'enregistrements après l'exécution d'une requête / procédure stockée
ADODB.Recordset - Utilisé pour récupérer les données d'une base de données
Comment se connecter à la base de données?
Les bases de données peuvent être connectées à l'aide de chaînes de connexion. Chaque base de données diffère dans la façon dont nous nous y connectons. Cependant, les chaînes de connexion peuvent être construites à l'aide de www.connectionstrings.com
Voyons comment se connecter à la base de données avec les paramètres suivants -
Database Type - SERVEUR MSSQL
Server Name - SQLEXPRESS
Database Name - Essai
User Id - sa
password - Mot de passe123
La sortie de la requête est affichée dans SQL Server Management Studio comme suit -
Dim objConnection
'Set Adodb Connection Object
Set objConnection = CreateObject("ADODB.Connection")
Dim objRecordSet
'Create RecordSet Object
Set objRecordSet = CreateObject("ADODB.Recordset")
Dim DBQuery 'Query to be Executed
DBQuery = "Select NAME from dbo.EMPLOYEE where AGE = 29"
'Connecting using SQL OLEDB Driver
objConnection.Open "Provider = sqloledb.1;Server =.\SQLEXPRESS;
User Id = sa;Password=Password123;Database = Trial"
'Execute the Query
objRecordSet.Open DBQuery,objConnection
'Return the Result Set
Value = objRecordSet.fields.item(0)
msgbox Value
' Release the Resources
objRecordSet.Close
objConnection.Close
Set objConnection = Nothing
Set objRecordSet = Nothing
Résultat
Lors de l'exécution du script ci-dessus, la sortie est affichée dans la boîte de message comme indiqué ci-dessous -
XML est un langage de balisage conçu pour stocker des données dans un format qui peut être à la fois lisible par l'homme et la machine. En utilisant XML, les données peuvent également être facilement échangées entre les systèmes informatiques et de bases de données.
Un exemple de XML et leurs éléments clés sont représentés ci-dessous -
Accéder au XML
Const XMLDataFile = "C:\TestData.xml"
Set xmlDoc = CreateObject("Microsoft.XMLDOM")
xmlDoc.Async = False
xmlDoc.Load(XMLDataFile)
' Getting the number of Nodes (books)
Set nodes = xmlDoc.SelectNodes("/bookstore/book")
Print "Total books: " & nodes.Length ' Displays 2
' get all titles
Set nodes = xmlDoc.SelectNodes("/Booklib/book/value/text()")
' get their values
For i = 0 To (nodes.Length - 1)
Title = nodes(i).NodeValue
Print "Title is" & (i + 1) & ": " & Title
Next
Comparer XML
Nous pouvons comparer deux XML donnés -
Dim xmlDoc1
Dim xmlDoc2
' Load the XML Files
Set xmlDoc1 = XMLUtil.CreateXMLFromFile ("C:\File1.xml")
Set xmlDoc2 = XMLUtil.CreateXMLFromFile ("C:\File2.xml")
'Use the compare method of the XML to check if they are equivalent
Comp = xmlDoc1.Compare (xmlDoc1, xmlDoc2)
'Returns 1 if the two files are the same
If Comp = 1 Then
Msgbox "XML Files are the Same"
Else
Msgbox "XML Files are Different"
End if
Les scripts QTP ne peuvent s'exécuter que si les objets sont présents dans le référentiel d'objets. Les descriptions des objets sont créées à l'aide de la programmation descriptive -
Lorsque les testeurs souhaitent effectuer une opération sur un objet qui n'est pas présent dans le référentiel d'objets
Lorsque les objets de l'application sont de nature très dynamique.
Lorsque le référentiel d'objets grossit, il en résulte des performances médiocres à mesure que la taille du référentiel d'objets augmente.
Lorsque le framework est construit, il a été décidé de ne pas du tout utiliser Object Repository.
Lorsque les testeurs souhaitent effectuer une action sur l'application au moment de l'exécution sans connaître les propriétés uniques de l'objet.
Syntaxe
Il existe deux façons de créer des scripts à l'aide de la technique de programmation descriptive. Ils sont -
- Objets de description
- Description Chaînes
Objets de description
Le script est développé à l'aide d'objets de description qui dépendent des propriétés utilisées et de leurs valeurs correspondantes. Ensuite, ces descriptions sont utilisées pour construire le script.
'Creating a description object
Set btncalc = Description.Create()
'Add descriptions and properties
btncalc("type").value = "Button"
btncalc("name").value = "calculate"
btncalc("html tag").value = "INPUT"
' Use the same to script it
Browser("Math Calc").Page("Num Calculator").WebButton(btncalc).Click
Description Chaînes
La description des objets est développée en utilisant les propriétés et les valeurs sous forme de chaînes comme indiqué ci-dessous.
Browser("Math Calc").Page("Num Calculator").WebButton("html
tag:=INPUT","type:=Button","name:=calculate").Click
Objets enfants
QTP fournit la méthode ChildObjects, qui nous permet de créer une collection d'objets. Les objets parents précèdent ChildObjects.
Dim oDesc
Set oDesc = Description.Create
oDesc("micclass").value = "Link"
'Find all the Links
Set obj = Browser("Math Calc").Page("Math Calc").ChildObjects(oDesc)
Dim i
'obj.Count value has the number of links in the page
For i = 0 to obj.Count - 1
'get the name of all the links in the page
x = obj(i).GetROProperty("innerhtml")
print x
Next
Identificateurs ordinaux
La programmation descriptive est utilisée pour écrire le script basé sur des identificateurs ordinaux, ce qui permettra à QTP d'agir sur ces objets lorsque deux objets ou plus ont les mêmes propriétés.
' Using Location
Dim Obj
Set Obj = Browser("title:=.*google.*").Page("micclass:=Page")
Obj.WebEdit("name:=Test","location:=0").Set "ABC"
Obj.WebEdit("name:=Test","location:=1").Set "123"
' Index
Obj.WebEdit("name:=Test","index:=0").Set "1123"
Obj.WebEdit("name:=Test","index:=1").Set "2222"
' Creation Time
Browser("creationtime:=0").Sync
Browser("creationtime:=1").Sync
Browser("creationtime:=2").Sync
QTP lui-même peut être automatisé à l'aide de l'interface COM fournie par HP-QTP. Le modèle d'objet d'automatisation est un ensemble d'objets, de méthodes et de propriétés qui aident les testeurs à contrôler les paramètres de configuration et à exécuter les scripts à l'aide de l'interface QTP. Les configurations / actions clés pouvant être contrôlées (mais sans s'y limiter) sont répertoriées ci-dessous -
- Charge tous les compléments requis pour un test
- Rend QTP visible pendant l'exécution
- Ouvre le test en utilisant l'emplacement spécifié
- Bibliothèques de fonctions associées
- Spécifie le délai d'expiration de la synchronisation des objets communs
- Début et fin de l'itération
- Activer / désactiver l'identification intelligente
- Sur les paramètres d'erreur
- Chemin de la table de données
- Paramètres du scénario de récupération
- Paramètres de suivi des journaux
QTP 11.5x fournit une documentation exclusive sur le modèle d'objet d'automatisation qui peut être référencée en accédant à "Démarrer" >> "Tous les programmes" >> "Logiciel HP" >> "HP Unified Functional Testing" >> "Documentation" >> "Unified Référence d'automatisation des tests fonctionnels ".
Générer un script AOM
Un testeur peut générer un script AOM à partir de QTP lui-même, en utilisant l'option "Generate Script". Accédez à "Exécuter" >> "Paramètres" >> "Onglet" Propriétés ">>" Générer un script "comme indiqué ci-dessous -
Exemple
' A Sample Script to Demostrate AOM
Dim App 'As Application
Set App = CreateObject("QuickTest.Application")
App.Launch
App.Visible = True
App.Test.Settings.Launchers("Web").Active = False
App.Test.Settings.Launchers("Web").Browser = "IE"
App.Test.Settings.Launchers("Web").Address = "http://easycalculation.com/"
App.Test.Settings.Launchers("Web").CloseOnExit = True
App.Test.Settings.Launchers("Windows Applications").Active = False
App.Test.Settings.Launchers("Windows Applications").Applications.RemoveAll
App.Test.Settings.Launchers("Windows Applications").RecordOnQTDescendants = True
App.Test.Settings.Launchers("Windows Applications").RecordOnExplorerDescendants = False
App.Test.Settings.Launchers("Windows Applications").RecordOnSpecifiedApplications = True
App.Test.Settings.Run.IterationMode = "rngAll"
App.Test.Settings.Run.StartIteration = 1
App.Test.Settings.Run.EndIteration = 1
App.Test.Settings.Run.ObjectSyncTimeOut = 20000
App.Test.Settings.Run.DisableSmartIdentification = False
App.Test.Settings.Run.OnError = "Dialog"
App.Test.Settings.Resources.DataTablePath = "<Default>"
App.Test.Settings.Resources.Libraries.RemoveAll
App.Test.Settings.Web.BrowserNavigationTimeout = 60000
App.Test.Settings.Web.ActiveScreenAccess.UserName = ""
App.Test.Settings.Web.ActiveScreenAccess.Password = ""
App.Test.Settings.Recovery.Enabled = True
App.Test.Settings.Recovery.SetActivationMode "OnError"
App.Test.Settings.Recovery.Add "D:\GUITest2\recover_app_crash.qrs",
"Recover_Application_Crash", 1
App.Test.Settings.Recovery.Item(1).Enabled = True
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' System Local Monitoring settings
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
App.Test.Settings.LocalSystemMonitor.Enable = false
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Log Tracking settings
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
With App.Test.Settings.LogTracking
.IncludeInResults = False
.Port = 18081
.IP = "127.0.0.1"
.MinTriggerLevel = "ERROR"
.EnableAutoConfig = False
.RecoverConfigAfterRun = False
.ConfigFile = ""
.MinConfigLevel = "WARN"
End With
Un cadre définit un ensemble de directives / bonnes pratiques qui applique un ensemble de normes, ce qui le rend facile à utiliser pour les utilisateurs finaux. Il existe différents types de frameworks d'automatisation et les plus courants sont répertoriés ci-dessous -
- Cadre basé sur les mots clés
- Cadre basé sur les données
- Cadre hybride
Cadre basé sur les mots clés
Le test piloté par mot-clé est un type de cadre de test d'automatisation fonctionnelle qui est également connu sous le nom de test piloté par table ou test basé sur un mot d'action.
Dans les tests basés sur les mots-clés, nous utilisons un format de tableau, généralement une feuille de calcul, pour définir des mots-clés ou des mots d'action pour chaque fonction que nous souhaitons exécuter.
Avantages
Il est le mieux adapté pour un novice ou un testeur non technique.
Permet d'écrire des tests de manière plus abstraite en utilisant cette approche.
Les tests pilotés par mots-clés permettent de démarrer l'automatisation plus tôt dans le SDLC avant même qu'une version stable ne soit fournie pour les tests.
Il existe un degré élevé de réutilisabilité.
Désavantages
L'investissement initial dans le développement des mots-clés et des fonctionnalités associées peut prendre plus de temps.
Cela pourrait agir comme une restriction pour les testeurs techniquement capables.
Cadre basé sur les données
Les tests basés sur les données sont la création de scripts de test dans lesquels les données de test et / ou les valeurs de sortie sont lues à partir de fichiers de données au lieu d'utiliser les mêmes valeurs codées en dur à chaque exécution du test. De cette façon, les testeurs peuvent tester la manière dont l'application gère efficacement différentes entrées. Il peut s'agir de l'un des fichiers de données suivants -
- datapools
- Fichiers Excel
- Objets ADO
- Fichiers CSV
- Sources ODBC
Représentation schématique
Les tests pilotés par les données peuvent être mieux compris par le diagramme suivant -
Avantages
- Le cadre basé sur les données génère moins de code
- Offre une plus grande flexibilité pour maintenir et résoudre les problèmes de script
- Les données de test peuvent être développées
Désavantages
- Chaque script doit être différent pour comprendre différents ensembles de données.
Cadre hybride
Le framework hybride est une combinaison de framework piloté par mot-clé et piloté par les données qui peut être mieux décrit à l'aide du diagramme de flux suivant.
Facteurs affectant
Voici les paramètres à prendre en compte lors de l'élaboration du cadre. Les facteurs affectant sont énumérés ci-dessous -
Les fichiers de cadre doivent prendre en charge les logiciels de contrôle de version tels que SVN, CVS, MS Source Control
Le cadre doit prendre en charge l'exécution des scripts dans différents environnements, à savoir QA, SAT, DEV
Lors des changements d'objet, les scripts doivent s'exécuter avec des modifications minimes.
Framework doit se configurer et prendre en charge les prérequis tels que la création de dossiers / bases de données.
Le cadre doit avoir une structure de rapport robuste afin que les problèmes dans le script / l'application puissent être facilement repérés
Le cadre devrait avoir une plus grande flexibilité afin qu'il soit facile à utiliser
Le cadre doit suivre les normes de codage afin que les fichiers, les fonctions et l'historique des modifications soient correctement conservés.
Dans le prochain chapitre, nous allons apprendre à concevoir un cadre simple.
Concevons un cadre simple en prenant un exemple d'application. Nous automatiserons quelques scénarios de l'application testée et écrirons des fonctions réutilisables.
L'exemple d'application testé est "Calculator", une application par défaut disponible dans le cadre de Windows. Créons maintenant différents composants d'un framework. Ici, nous allons développer un framework hybride et utiliser Object Repository car il s'agit d'une application assez simple. Cependant, ce cadre peut également être mis à l'échelle pour prendre en charge une application complexe.
La structure des dossiers du Framework est illustrée ci-dessous -
Explication de la structure des dossiers -
Master Driver Script- Le script qui pilote toute l'exécution. Il effectue les paramètres préalables et initiaux nécessaires à l'exécution.
Library Files - Les fonctions associées qui forment la bibliothèque de fonctions.
Data Table - Les données de test requises pour l'exécution.
Object Repository - Les objets et ses propriétés qui permettent à QTP de reconnaître les objets de manière transparente.
Execution Logs - Le dossier contient le fichier journal d'exécution avec les fonctions utilisateur et l'historique d'exécution des fonctions.
Script de pilote principal
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
' MASTER DRIVER SCRIPT NAME : Calculator
' DESCRIPTION : Drivers Script to Execute Automated Test for
the Calculator
' AUTHOR : Tutorials Point
' DATE CREATED : 30-Dec-2013
' OBJECT REPOSITORY ASSOCIATED : Calc.tsr
' LIBRARY FILES ASSOCIATED : calculator.qfl, Common.qfl
' MODIFICATION LOG
' ----------------------------------------------------
' First Version Tutorials point
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
Option Explicit
Public ExecDrive
' Get the Root folder of the Test so that we can make use of relative paths.
Dim x : x = Instr(Environment.Value("TestDir"),"Driver")-2
ExecDrive = mid(Environment.Value("TestDir"),1,x)
' Get the path of Libraries using relative to the current Drive
Dim LibPath : LibPath = ExecDrive+"\Libraries\"
' Dynamically Load the Function Libraries
LoadFunctionLibrary LibPath + "Calculator.qfl", LibPath + "common_utils.qfl"
' Capturing the Start Time
' clscommon is the class object created in common.qfl library file
clscommon.StartTime = Time()
' Launching the Application
SystemUtil.Run "C:\Windows\System32\Calc.exe" : wait (2)
' Initialize the Data Table Path
Dim FileName : FileName = ExecDrive+"\TestData\Calculator.xls"
Dim SheetSource : SheetSource = "Calc_test"
Dim SheetDest : SheetDest = "Global"
' Import the DataTable into the QTP Script
DataTable.ImportSheet FileName , SheetSource , SheetDest
' Object Repository Path
Dim RepPath : RepPath = ExecDrive+"\Object_Repository\Calc.tsr"
RepositoriesCollection.RemoveAll()
RepositoriesCollection.Add(RepPath)
' To Keep a Count on iteration
Dim InttestIteration
Dim InttestRows : InttestRows = datatable.GetRowCount
' Fetching Date-TimeStamp which will be unique for Naming the Execution Log File
clscommon.StrDateFormatted = day(date()) & "_" & MonthName(Month(date()),true) &
"_" & YEAR(date())& "_"&hour(now)&"_"&minute(now)
' Name the LogFile
clscommon.StrLogFile = ExecDrive & "\Execution Logs\" &
clscommon.StrDateFormatted & ".txt"
' Create the Execution LogFile which captures the result
clscommon.Fn_FileCreate(clscommon.StrLogFile)
' Iniitialize the Parameters and all the relevant Test Details
Call Fn_InitializeLogFile()
' Kill all the previous calculator process
Call fn_Kill_Process("calc.exe")
For InttestIteration = 1 to InttestRows
datatable.SetCurrentRow InttestIteration
Dim StrExecute : StrExecute = Ucase(Trim(datatable.Value("Run","Global")))
If StrExecute = "Y" Then
clscommon.Number1 = Trim(datatable.Value("Number_1","Global"))
clscommon.Number2 = Trim(datatable.Value("Number_2","Global"))
clscommon.Number3 = Trim(datatable.Value("Number_3","Global"))
clscommon.Number4 = Trim(datatable.Value("Number_4","Global"))
clscommon.Number5 = Trim(datatable.Value("Number_5","Global"))
clscommon.Number6 = Trim(datatable.Value("Number_6","Global"))
clscommon.Test_Case_ID =
Trim(datatable.Value("Test_Case_ID","Global"))'
: clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath
clscommon.tcScenario =
Trim(datatable.Value("Scenario","Global"))'
: clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath
Dim Expected_Val : Expected_Val =
Trim(datatable.Value("Expected_Val","Global"))'
: clscommon.LogWrite "The Test Case Data is Located at :: " & tcDataPath
Select case clscommon.tcScenario
Case "Add"
clscommon.LogWrite "=== Inside the Test Set :: " &
clscommon.tcScenario & " ==="
Call fnCalculate("+",Expected_Val)
Case "Subtract"
clscommon.LogWrite "=== Inside the Test Set :: " &
clscommon.tcScenario & " ==="
Call fnCalculate("-",Expected_Val)
Case "Multiply"
clscommon.LogWrite "=== Inside the Test Set :: " &
clscommon.tcScenario & " ==="
Call fnCalculate("*",Expected_Val)
Case "Divide"
clscommon.LogWrite "=== Inside the Test Set :: " &
clscommon.tcScenario & " ==="
Call fnCalculate("/",Expected_Val)
Case "Sqrt"
clscommon.LogWrite "=== Inside the Test Set :: " &
clscommon.tcScenario & " ==="
Call fnCalculate("sqt",Expected_Val)
End Select
End If
Next
' Calling the End Test to Add the result Footer in exec log file.
Call fn_End_test()
' ===================== End of Master Driver Script =====================
Fichiers de bibliothèque
Les fonctions de la calculatrice sont écrites dans un fichier de fonction distinct enregistré avec l'extension .qfl ou .vbs. Ces fonctions sont réutilisables dans toutes les actions.
' Calculator. Qfl File :: Associated Function Library for Calculator Master Driver
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
' FUNCTION NAME : Fn_InitializeLogFile
' DESCRIPTION : Function to Write the Initial Values in the Log File
' INPUT PARAMETERS : varExecDrive,StrDB,StrUId,Strpwd,StrNewDB
' OUTPUT PARAMETERS : NIL
' RETURN VALUE : Pass or Fail message
' DATE CREATED : 30-Dec-2013
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
Public Function Fn_InitializeLogFile()
clscommon.LogWrite "********************************************"
clscommon.LogWrite "Calc Automation Started"
End Function
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
' FUNCTION NAME : fnCalculate
' DESCRIPTION : Function to perform Arithmetic Calculations
' INPUT PARAMETERS : operator,Expected_Val
' OUTPUT PARAMETERS : NIL
' RETURN VALUE : Pass or Fail message
' DATE CREATED : 30-Dec-2013
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
Function fnCalculate(operator,Expected_Val)
clscommon.LogWrite "Executing the Function 'fnCalculate' "
Window("Calculator").Activate
If Trim(clscommon.Number1) <> "" Then
Window("Calculator").WinButton(clscommon.Number1).Click
If Trim(clscommon.Number2) <> "" Then
Window("Calculator").WinButton(clscommon.Number2).Click
If Trim(clscommon.Number3) <> "" Then
Window("Calculator").WinButton(clscommon.Number3).Click
Window("Calculator").WinButton(operator).Click
If Trim(clscommon.Number4) <> "" Then
Window("Calculator").WinButton(clscommon.Number4).Click
If Trim(clscommon.Number5) <> "" Then
Window("Calculator").WinButton(clscommon.Number5).Click
If Trim(clscommon.Number6) <> "" Then
Window("Calculator").WinButton(clscommon.Number6).Click
Window("Calculator").WinButton("=").Click
Dim ActualVal : ActualVal =
Window("Calculator").WinEdit("Edit").GetROProperty("text")
clscommon.LogWrite "The Actual Value after the Math Operation is "& ActualVal
If Trim(ActualVal) = Trim(Expected_Val) Then
clscommon.WriteResult "Pass", clscommon.Test_Case_ID ,
clscommon.tcScenario , " Expected Value matches with Actual Value :: "
& ActualVal
Else
clscommon.WriteResult "Fail", clscommon.Test_Case_ID ,
clscommon.tcScenario , " Expected Value - " & Expected_Val & " Does NOT matches
with Actual Value :: " & ActualVal
End If
Window("Calculator").WinButton("C").Click
If Err.Number <> 0 Then
clscommon.LogWrite "Execution Error : The Error Number is :: " &
Err.Number & " The Error Description is " & Err.Description
Err.Clear
End If
clscommon.LogWrite "Exiting the Function 'fnCalculate' "
End Function
'= = = = = = = = = = = = = = = = = = = = = = = = = = =
' FUNCTION NAME : fn_Kill_Process
' DESCRIPTION : Function to Kill the process by name
' INPUT PARAMETERS : Application name to be killed
' OUTPUT PARAMETERS : NIL
' RETURN VALUE : NIL
' DATE CREATED : 30-Dec-2013
'= = = = = = = = = = = = = = = = = = = = = = = = = = =
Function fn_Kill_Process(process)
Dim strComputer , strProcessToKill , objWMIService , colProcessstrComputer = "."
strProcessToKill = process
Set objWMIService = GetObject("winmgmts:" _&
"{impersonationLevel=impersonate}!\\" _& strComputer & "\root\cimv2")
Set colProcess = objWMIService.ExecQuery _("Select * from Win32_Process
Where Name = '" & strProcessToKill & "'")
count = 0
For Each objProcess in colProcess
objProcess.Terminate()
count = count + 1
Next
End Function
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
' FUNCTION NAME : fn_End_test
' DESCRIPTION : Function to finish the test Execution process
' INPUT PARAMETERS : Application name to be killed
' OUTPUT PARAMETERS : NIL
' RETURN VALUE : NIL
' DATE CREATED : 20/Dec/2013
'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
Function fn_End_test()
clscommon.LogWrite "Status Message - Executing the Function 'fn_End_test' "
Window("Calculator").Close
On Error Resume Next
clscommon.StopTime = Time()
clscommon.ElapsedTime = DateDiff("n",clscommon.StartTime,clscommon.StopTime)
Dim Totaltests
Totaltests = clscommon.gintPassCount+ clscommon.gintFailCount
clscommon.LogWrite "## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
clscommon.LogWrite "## The Execution Start Time :: " & clscommon.StartTime
clscommon.LogWrite "## The Execution End Time :: " & clscommon.StopTime
clscommon.LogWrite "## The Time Elapsed :: " & clscommon.ElapsedTime & " Minutes "
clscommon.LogWrite "## The OS :: " & Environment.Value("OS")
clscommon.LogWrite "## The Total No of Test Cases Executed :: " & Totaltests
clscommon.LogWrite "## The No. of Test Case Passed :: " & clscommon.gintPassCount
clscommon.LogWrite "## The No. of Test Case Failed :: " & clscommon.gintFailCount
clscommon.LogWrite "## # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
SystemUtil.CloseDescendentProcesses
End Function
' =============== End of Calculator. Qfl ============================= '
L'autre fichier de bibliothèque, qui est 'common_utils.qfl' qui contient les fonctions, qui nous permet d'écrire la sortie dans un fichier texte.
Set clscommon = New OS_clsUtils
'Creating a class file to handle global variables.
Class OS_clsUtils
Dim StrLogFile
Dim StrDateFormatted
Dim Result
Dim Number1, Number2 , Number3
Dim Number4, Number5 , Number6
Dim Test_Case_ID , tcScenario
Dim StartTime, StopTime, ElapsedTime
Dim gintPassCount , gintFailCount , gintWarningCount , gintdoneCount,
gintinfoCount
Function Fn_FileCreate(strFileName)
Dim objFSO: Set objFSO = CreateObject("Scripting.FileSystemObject")
On Error Resume Next
Dim objTextFile : Set objTextFile = objFSO.CreateTextFile(strFileName)
objTextFile.Close
Set objTextFile = Nothing
Set objFSO = Nothing
End Function
Function LogWrite(sMsg)
Const ForAppending = 8
Dim objFSO : Set objFSO = CreateObject("scripting.FileSystemObject")
Dim objTextFile : Set objTextFile = objFSO.OpenTextFile
(clscommon.StrLogFile, ForAppending, True)
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & sMsg
objTextFile.Close
Set objTextFile = Nothing
Set objFSO = Nothing
End Function
Function WriteResult(strStatus,functionName,functionDescription,Result)
Const ForAppending = 8
Dim objFSO : Set objFSO = CreateObject("scripting.FileSystemObject")
Dim objTextFile : Set objTextFile = objFSO.OpenTextFile
(clscommon.StrLogFile, ForAppending, True)
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & "
* * * * * * Test Case Exec Details * * * * * "
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & " Test staus :: " & strStatus
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & " Tese ID :: " & functionName
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & " Test Description :: "
& functionDescription
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & " Test Result Details :: " & Result
objTextFile.WriteLine day(date()) & "/" & MonthName(Month(date()),true)
& "/" & YEAR(date()) & " " & time & ": " & "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * "
objTextFile.Close
Set objTextFile = Nothing
Set objFSO = Nothing
Select Case Lcase(strStatus)
Case "pass"
gintPassCount = gintPassCount + 1
Case "fail"
gintFailCount = gintFailCount+1
End Select
End Function
End Class
' ===================== End of common_Utils.qfl =====================
Référentiel d'objets
Object Repository a tous les objets sur lesquels l'utilisateur agirait. L'image ci-dessous montre la liste de tous les objets ajoutés dans le référentiel avec le nom calc.tsr
Tableau de données
DataTable contient les mots-clés, qui pilotent les tests et testent également les données avec lesquelles QTP agira sur les objets.
Le journal d'exécution
Le fichier journal d'exécution ou le fichier de sortie contient les actions utilisateur et le journal des fonctions, qui permettront aux testeurs de déboguer en cas d'échec du script.
8/Jan/2014 5:09:16 PM: *************************************************
8/Jan/2014 5:09:16 PM: Calc Automation Started
8/Jan/2014 5:09:16 PM: === Inside the Test Set :: Add ===
8/Jan/2014 5:09:16 PM: Executing the Function 'fnCalculate'
8/Jan/2014 5:09:17 PM: The Actual Value after the Math Operation is 949.
8/Jan/2014 5:09:17 PM: * * * * * * Test Case Exec Details * * * * *
8/Jan/2014 5:09:17 PM: Test staus :: Pass
8/Jan/2014 5:09:17 PM: Tese ID :: TC_001
8/Jan/2014 5:09:17 PM: Test Description :: Add
8/Jan/2014 5:09:17 PM: Test Result Details :: Expected Value matches with Actual
Value :: 949.
8/Jan/2014 5:09:17 PM: * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * *
8/Jan/2014 5:09:17 PM: Exiting the Function 'fnCalculate'
8/Jan/2014 5:09:17 PM: === Inside the Test Set :: Subtract ===
8/Jan/2014 5:09:17 PM: Executing the Function 'fnCalculate'
8/Jan/2014 5:09:17 PM: The Actual Value after the Math Operation is 415.
8/Jan/2014 5:09:17 PM: * * * * * * Test Case Exec Details * * * * *
8/Jan/2014 5:09:17 PM: Test staus :: Pass
8/Jan/2014 5:09:17 PM: Tese ID :: TC_002
8/Jan/2014 5:09:17 PM: Test Description :: Subtract
8/Jan/2014 5:09:17 PM: Test Result Details :: Expected Value matches with Actual
Value :: 415.
8/Jan/2014 5:09:17 PM: * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * *
8/Jan/2014 5:09:17 PM: Exiting the Function 'fnCalculate'
8/Jan/2014 5:09:17 PM: === Inside the Test Set :: Multiply ===
8/Jan/2014 5:09:17 PM: Executing the Function 'fnCalculate'
8/Jan/2014 5:09:18 PM: The Actual Value after the Math Operation is 278883.
8/Jan/2014 5:09:18 PM: * * * * * * Test Case Exec Details * * * * *
8/Jan/2014 5:09:18 PM: Test staus :: Pass
8/Jan/2014 5:09:18 PM: Tese ID :: TC_003
8/Jan/2014 5:09:18 PM: Test Description :: Multiply
8/Jan/2014 5:09:18 PM: Test Result Details :: Expected Value matches with
Actual Value :: 278883.
8/Jan/2014 5:09:18 PM: * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * *
8/Jan/2014 5:09:18 PM: Exiting the Function 'fnCalculate'
8/Jan/2014 5:09:18 PM: === Inside the Test Set :: Divide ===
8/Jan/2014 5:09:18 PM: Executing the Function 'fnCalculate'
8/Jan/2014 5:09:19 PM: The Actual Value after the Math Operation is 3.
8/Jan/2014 5:09:19 PM: * * * * * * Test Case Exec Details * * * * *
8/Jan/2014 5:09:19 PM: Test staus :: Pass
8/Jan/2014 5:09:19 PM: Tese ID :: TC_004
8/Jan/2014 5:09:19 PM: Test Description :: Divide
8/Jan/2014 5:09:19 PM: Test Result Details :: Expected Value matches with Actual
Value :: 3.
8/Jan/2014 5:09:19 PM: * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * *
8/Jan/2014 5:09:19 PM: Exiting the Function 'fnCalculate'
8/Jan/2014 5:09:19 PM: === Inside the Test Set :: Sqrt ===
8/Jan/2014 5:09:19 PM: Executing the Function 'fnCalculate'
8/Jan/2014 5:09:20 PM: The Actual Value after the Math Operation is 10.
8/Jan/2014 5:09:20 PM: * * * * * * Test Case Exec Details * * * * *
8/Jan/2014 5:09:20 PM: Test staus :: Pass
8/Jan/2014 5:09:20 PM: Tese ID :: TC_005
8/Jan/2014 5:09:20 PM: Test Description :: Sqrt
8/Jan/2014 5:09:20 PM: Test Result Details :: Expected Value matches with Actual
Value :: 10.
8/Jan/2014 5:09:20 PM: * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * *
8/Jan/2014 5:09:20 PM: Exiting the Function 'fnCalculate'
8/Jan/2014 5:09:20 PM: Status Message - Executing the Function 'fn_Finish_test'
8/Jan/2014 5:09:20 PM: ## # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # #
8/Jan/2014 5:09:20 PM: ## The Execution Start Time :: 5:09:14 PM
8/Jan/2014 5:09:20 PM: ## The Execution End Time :: 5:09:20 PM
8/Jan/2014 5:09:20 PM: ## The Time Elapsed :: 0 Minutes
8/Jan/2014 5:09:20 PM: ## The OS :: Microsoft Windows Vista Server
8/Jan/2014 5:09:20 PM: ## The Total No of Test Cases Executed :: 25
8/Jan/2014 5:09:20 PM: ## The No. of Test Case Passed :: 25
8/Jan/2014 5:09:20 PM: ## The No. of Test Case Failed ::
8/Jan/2014 5:09:20 PM: ## # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # #