Selenium WebDriver – Documentation Selenium – Serveur d’impression
REMARQUE: nous travaillons actuellement à la documentation de ces sections.
Nous pensons que les informations ici sont exactes, mais sachez que nous travaillons toujours sur ce
chapitre. Des informations supplémentaires seront fournies au fur et à mesure, ce qui devrait rendre ce chapitre plus utile.
solide.
Sommaire
Présentation de WebDriver
La principale nouvelle fonctionnalité de Selenium 2.0 est l'intégration de l'API WebDriver.
WebDriver est conçu pour fournir une interface de programmation plus simple et plus concise en plus de
résoudre certaines limitations de l’API Selenium-RC. Selenium-WebDriver a été développé
pour mieux prendre en charge les pages Web dynamiques où des éléments d'une page peuvent changer sans la page
lui-même étant rechargé. L’objectif de WebDriver est de fournir une solution orientée objet bien conçue.
API offrant une prise en charge améliorée des problèmes de test d'applications Web avancés et avancés.
Comment WebDriver "pilote-t-il" le navigateur par rapport à Selenium-RC?
Selenium-WebDriver appelle directement le navigateur en utilisant le support natif de chaque navigateur pour l’automatisation.
La manière dont ces appels directs sont effectués et les fonctionnalités qu’ils prennent en charge dépend du navigateur que vous utilisez.
Des informations sur chaque ‘pilote de navigateur’ sont fournies plus loin dans ce chapitre.
Pour ceux qui sont familiers avec Selenium-RC, c'est très différent de ce que vous avez l'habitude de faire. Sélénium-RC
fonctionné de la même manière pour chaque navigateur pris en charge. Il "injecte" des fonctions javascript dans le navigateur
lorsque le navigateur a été chargé et a ensuite utilisé son javascript pour piloter l’AUT dans le navigateur.
WebDriver n'utilise pas cette technique. Encore une fois, il pilote le navigateur directement à l'aide de son navigateur.
support intégré pour l'automatisation.
WebDriver et le Selenium-Server
Le serveur Selenium peut être nécessaire ou non, selon l’utilisation que vous envisagez d’utiliser Selenium-WebDriver.
Si votre navigateur et vos tests s'exécutent tous sur le même ordinateur et que vos tests utilisent uniquement l'API WebDriver,
alors vous n'avez pas besoin d'exécuter le serveur Selenium; WebDriver exécutera le navigateur directement.
Cependant, il existe certaines raisons d'utiliser Selenium-Server avec Selenium-WebDriver.
- Vous utilisez Selenium-Grid pour répartir vos tests sur plusieurs machines ou machines virtuelles (VM).
- Vous souhaitez vous connecter à un ordinateur distant doté d'une version de navigateur particulière qui n'est pas activée
votre machine actuelle.- Vous n'utilisez pas les liaisons Java (c'est-à-dire Python, C # ou Ruby) et souhaitez utiliser le pilote HtmlUnit
Configuration d'un projet Selenium-WebDriver
Installer Selenium signifie configurer un projet dans un développement pour pouvoir écrire un programme en utilisant
Sélénium. Cela dépend de votre langage de programmation et de votre environnement de développement.
Java
Le moyen le plus simple de configurer un projet Java Selenium 2.0 consiste à utiliser Maven. Maven téléchargera le
java (la bibliothèque du client java Selenium 2.0) et toutes ses dépendances, et créera le
projet pour vous, en utilisant un fichier maven pom.xml (configuration du projet). Une fois que vous avez fait cela, vous
pouvez importer le projet maven dans votre IDE préféré, IntelliJ IDEA ou Eclipse.
Commencez par créer un dossier contenant vos fichiers de projet Selenium. Ensuite, pour utiliser Maven, vous avez besoin d’un
fichier pom.xml. Cela peut être créé avec un éditeur de texte. Nous n’enseignerons pas le
des détails sur les fichiers pom.xml ou sur l'utilisation de Maven car il existe déjà d'excellentes références à ce sujet.
Votre fichier pom.xml ressemblera à ceci. Créez ce fichier dans le dossier que vous avez créé pour
votre projet.
<projet xmlns ="http://maven.apache.org/POM/4.0.0"
xmlns: xsi ="http://www.w3.org/2001/XMLSchema-instance"
xsi: schemaLocation ="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
Assurez-vous de spécifier la version la plus récente. Au moment de la rédaction, la version indiquée ci-dessus était
les plus courants, cependant, des rejets fréquents ont eu lieu immédiatement après la publication de Selenium 2.0.
Consultez la page de téléchargement de Maven pour connaître la version actuelle et éditez la dépendance ci-dessus en conséquence.
Maintenant, à partir d'une ligne de commande, CD dans le répertoire du projet et exécutez maven comme suit.
Cela téléchargera Selenium et toutes ses dépendances et les ajoutera au projet.
Enfin, importez le projet dans votre environnement de développement préféré. Pour ceux qui ne connaissent pas
avec cela, nous avons fourni une annexe qui montre cela.
Importer un projet maven dans IntelliJ IDEA.
Importer un projet maven dans Eclipse.
C #
A partir de Selenium 2.2.0, les liaisons C # sont distribuées sous la forme d’un ensemble de dll signées avec d’autres
dépendance dlls. Avant la version 2.2.0, toutes les dll de Selenium n’étaient pas signées.
Pour inclure Selenium dans votre projet, téléchargez simplement la dernière
fichier zip sélénium-dotnet de http://selenium-release.storage.googleapis.com/index.html.
Si vous utilisez Windows Vista ou supérieur, vous devez débloquer le fichier zip avant
Décompressez-le: Faites un clic droit sur le fichier zip, cliquez sur «Propriétés», cliquez sur «Débloquer»
et cliquez sur “OK”.
Décompressez le contenu du fichier zip et ajoutez une référence à chacun des fichiers décompressés.
DLL à votre projet dans Visual Studio (ou votre IDE de choix).
Paquets officiels NuGet:
RC
WebDriver
WebDriverBackedSelenium
Soutien
Python
Si vous utilisez Python pour l’automatisation des tests, vous êtes probablement déjà familiarisé avec le développement.
en Python. Pour ajouter Selenium à votre environnement Python, exécutez la commande suivante à partir de
une ligne de commande.
Pip nécessite l'installation de pip. Pip a également une dépendance.
sur setuptools.
L’enseignement du développement Python lui-même dépasse le cadre de ce document, mais il existe de nombreux
Les ressources sur Python et les développeurs potentiels de votre organisation peuvent vous aider à vous mettre à niveau.
Rubis
Si vous utilisez Ruby pour l’automatisation des tests, vous êtes probablement déjà familiarisé avec le développement.
en rubis. Pour ajouter Selenium à votre environnement Ruby, exécutez la commande suivante à partir de
une ligne de commande.
bijou installer sélénium-webdriver
L’enseignement du développement de Ruby lui-même dépasse le cadre de ce document, mais il existe de nombreuses
Les ressources sur Ruby et les développeurs potentiels de votre organisation peuvent vous aider à vous mettre à niveau.
Perl
Les liaisons Perl sont fournies par des tiers. Veuillez vous reporter à la documentation correspondante pour savoir comment
installer / commencer. Il existe une liaison Perl connue à ce jour.
JavaScript
Si vous utilisez node.js pour développer votre application, le projet sélénium fournit des liaisons Javascript sur npm.
Installez les liaisons Javascript avec npm:
npm installer sélénium-webdriver
Vous pouvez trouver la documentation de l'API ici.
Migration de Selenium 1.0
Pour ceux qui ont déjà écrit des suites de tests en utilisant Selenium 1.0, nous avons fourni des conseils sur la façon de
migrez votre code existant vers Selenium 2.0. Simon Stewart, développeur principal de Selenium 2.0,
a écrit un article sur la migration de Selenium 1.0. Nous avons inclus cela en annexe.
Migration de Selenium RC vers Selenium WebDriver
Présentation de l'API Selenium-WebDriver par exemple
WebDriver est un outil permettant d’automatiser le test d’applications Web, en particulier
pour vérifier qu'ils fonctionnent comme prévu. Son objectif est de fournir une API conviviale
facile à explorer et à comprendre, plus facile à utiliser que l'API Selenium-RC (1.0),
ce qui aidera à rendre vos tests plus faciles à
lire et maintenir. Il n’est lié à aucun cadre de test particulier, il peut donc
être utilisé aussi bien dans un projet de test unitaire ou à partir d’une ancienne méthode «principale».
Cette section présente l’API de WebDriver et vous aide à commencer à devenir
familier avec elle. Commencez par configurer un projet WebDriver si vous ne l’avez pas déjà fait.
Ceci a été décrit dans la section précédente, Configuration d'un projet Selenium-WebDriver.
Une fois votre projet configuré, vous pouvez voir que WebDriver agit comme n'importe quelle bibliothèque normale:
entièrement autonome, et vous n’avez généralement pas besoin de vous souvenir de commencer
processus supplémentaires ou exécuter les programmes d'installation avant de l'utiliser, par opposition au serveur proxy
avec Selenium-RC.
Remarque: des étapes supplémentaires sont nécessaires pour utiliser ChromeDriver, Opera Driver, Android Driver.
et pilote iOS
Vous êtes maintenant prêt à écrire du code. Voici un moyen facile de commencer
exemple, qui recherche le terme "Fromage" sur Google, puis affiche le
titre de la page de résultats sur la console.
paquet org.openqa.selenium.example;
importation org.openqa.selenium.By;
importation org.openqa.selenium.WebDriver;
importation org.openqa.selenium.WebElement;
importation org.openqa.selenium.firefox.FirefoxDriver;
importation org.openqa.selenium.support.ui.ExpectedCondition;
importation org.openqa.selenium.support.ui.WebDriverWait;
Publique classe Selenium2Example
Publique statique vide principale(Chaîne[] args)
// Créer une nouvelle instance du pilote Firefox
// Notez que le reste du code repose sur l'interface,
// pas la mise en œuvre.
WebDriver chauffeur = Nouveau FirefoxDriver();
// Et maintenant, utilisez ceci pour visiter Google
chauffeur.obtenir("http://www.google.com")
// Alternativement, la même chose peut être faite comme ça
// driver.navigate (). to ("http://www.google.com");
// Trouver l'élément de saisie de texte par son nom
WebElement élément = chauffeur.findElement(Par.prénom("q"));
// Entrez quelque chose à rechercher
élément.sendKeys("Fromage!")
// Soumettez maintenant le formulaire. WebDriver trouvera la forme pour nous à partir de l'élément
élément.soumettre();
// Vérifier le titre de la page
Système.en dehors.imprimer("Le titre de la page est:" + chauffeur.getTitle());
// La recherche de Google est rendue dynamiquement avec JavaScript.
// Attend le chargement de la page, délai d'expiration après 10 secondes
(Nouveau WebDriverWait(chauffeur, dix)).jusqu'à ce que(Nouveau Condition attendue<Booléen> ()
Publique Booléen appliquer(WebDriver ré)
revenir ré.getTitle()toLowerCase()commence avec("fromage!")
);
// devrait voir: "cheese! - Google Search"
Système.en dehors.imprimer("Le titre de la page est:" + chauffeur.getTitle());
// Fermer le navigateur
chauffeur.quitter();
en utilisant OpenQA.Selenium;
en utilisant OpenQA.Selenium.Firefox;
// Requiert une référence à WebDriver.Support.dll
en utilisant OpenQA.Selenium.Support.UI;
classe GoogleSuggest
statique vide Principale(chaîne[] args)
// Crée une nouvelle instance du pilote Firefox.
// Notez qu'il est encapsulé dans une clause using afin que le navigateur soit fermé
// et le WebDriver est disposé (même face aux exceptions).
// Notez également que le reste du code repose sur l'interface,
// pas la mise en œuvre.
// Notez également que d'autres pilotes (InternetExplorerDriver,
// ChromeDriver, etc.) nécessitera une configuration supplémentaire
// avant que cet exemple fonctionne. Voir les pages wiki pour le
// pilotes individuels sur http://code.google.com/p/selenium/wiki
// pour plus d'informations.
en utilisant (IWebDriver chauffeur = Nouveau FirefoxDriver())
// Remarque la navigation est légèrement différente de la version Java
// C'est parce que 'get' est un mot clé en C #
chauffeur.Naviguer()GoToUrl("http://www.google.com/")
// Trouver l'élément de saisie de texte par son nom
IWebElement question = chauffeur.FindElement(Par.prénom("q"));
// Entrez quelque chose à rechercher
question.SendKeys("Fromage")
// Soumettez maintenant le formulaire. WebDriver trouvera la forme pour nous à partir de l'élément
question.Soumettre();
// La recherche de Google est rendue dynamiquement avec JavaScript.
// Attend le chargement de la page, délai d'expiration après 10 secondes
var attendre = Nouveau WebDriverWait(chauffeur, TimeSpan.À partir de secondes(dix));
attendre.Jusqu'à ce que(ré => ré.Titre.Commence avec("fromage", Comparaison de chaînes.OrdinalIgnoreCase));
// devrait voir: "Cheese - Google Search" (pour une locale anglaise)
Console.WriteLine("Le titre de la page est:" + chauffeur.Titre)
de sélénium importation webdriver
de sélénium.common.exceptions importation TimeoutException
de selenium.webdriver.support.ui importation WebDriverWait # disponible depuis 2.4.0
de selenium.webdriver.support importation conditions_attendues comme CE # disponible depuis 2.26.0
# Créer une nouvelle instance du pilote Firefox
chauffeur = webdriver.Firefox()
# aller à la page d'accueil de google
chauffeur.obtenir("http://www.google.com")
# la page est ajaxy donc le titre est à l'origine ceci:
impression chauffeur.Titre
# trouve que l'attribut name est q (le champ de recherche google)
inputElement = chauffeur.find_element_by_name("q")
# tapez dans la recherche
inputElement.send_keys("fromage!")
# soumettre le formulaire (bien que google recherche automatiquement maintenant sans soumettre)
inputElement.soumettre()
essayer:
# nous devons attendre que la page se rafraîchit, la dernière chose qui semble avoir été mise à jour est le titre
WebDriverWait(chauffeur, dix).jusqu'à ce que(CE.title_contains("fromage!"))
# Vous devriez voir "fromage! - Recherche Google"
impression chauffeur.Titre
enfin:
chauffeur.quitter()
exiger 'rubygems'
exiger 'sélénium-webdriver'
chauffeur = Sélénium::WebDriver.pour : firefox
chauffeur.obtenir "http://google.com"
élément = chauffeur.find_element :prénom => "q"
élément.send_keys "Fromage!"
élément.soumettre
met "Le titre de la page est #driver.title "
attendre = Sélénium::WebDriver::Attendre.Nouveau(:temps libre => dix)
attendre.jusqu'à ce que chauffeur.Titre.downcase.Commencer avec? "fromage!"
met "Le titre de la page est #driver.title "
chauffeur.quitter
var chauffeur = Nouveau webdriver.Constructeur()construire();
chauffeur.obtenir("http://www.google.com")
var élément = chauffeur.findElement(webdriver.Par.prénom('q'));
élément.sendKeys('Fromage!')
élément.soumettre();
chauffeur.getTitle()puis(une fonction(Titre)
console.bûche('Le titre de la page est:' + Titre)
);
chauffeur.attendre(une fonction()
revenir chauffeur.getTitle()puis(une fonction(Titre)
revenir Titre.toLowerCase()lastIndexOf('fromage!', 0) === 0;
);
, 3000)
chauffeur.getTitle()puis(une fonction(Titre)
console.bûche('Le titre de la page est:' + Titre)
);
chauffeur.quitter();
utilisation Sélénium :: Télécommande :: Pilote;
# Créer une nouvelle instance du pilote
mon conducteur $ = Sélénium :: Télécommande :: Pilote->Nouveau;
# Aller à la page d'accueil de Google
conducteur $->obtenir("http://www.google.com")
# Imprimer le titre de la page d'origine
mon $ title = conducteur $->get_title();
impression "$ title n";
# Trouver l'élément dont l'attribut name est q (champ de recherche Google)
mon $ inputElement = conducteur $->find_element("q", "prénom")
# tapez dans la recherche
$ inputElement->send_keys("fromage!")
# soumettre le formulaire (bien que google recherche automatiquement maintenant sans soumettre)
$ inputElement->soumettre();
# Définissez le délai d'expiration de la recherche d'éléments sur 10 secondes (0 par défaut)
conducteur $->set_implicit_wait_timeout(10000)
# puis utilisez XPath pour rechercher un titre de page contenant du fromage!
conducteur $->find_element("/ html / head / title[contains(translate(., 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), 'cheese!')]")
# Vous devriez voir "fromage! - Recherche Google"
$ title = conducteur $->get_title();
impression "$ title n";
conducteur $->quitter();
Dans les prochaines sections, vous en apprendrez plus sur l’utilisation de WebDriver pour des applications
telles que la navigation en avant et en arrière dans l’historique de votre navigateur, et comment
tester des sites Web qui utilisent des cadres et des fenêtres. Nous fournissons également un plus
discussions approfondies et exemples.
Commandes et opérations de l'API Selenium-WebDriver
Aller chercher une page
La première chose que vous souhaiterez probablement faire avec WebDriver est d’accéder à une page.
La façon habituelle de faire ceci est d'appeler “get”:
chauffeur.obtenir("http://www.google.com")
chauffeur.URL = "http://www.google.com";
chauffeur.obtenir "http://www.google.com"
chauffeur.obtenir("http://www.google.com")
conducteur $->obtenir("http://www.google.com")
chauffeur.obtenir("http://www.google.com")
Dépend de plusieurs facteurs, y compris la combinaison système d'exploitation / navigateur,
WebDriver peut attendre ou ne pas attendre le chargement de la page. Dans certaines circonstances,
WebDriver peut rendre le contrôle avant que le chargement de la page soit terminé ou même commencé.
Pour assurer la robustesse, vous devez attendre que le ou les éléments existent dans la page à l'aide de
Attentes explicites et implicites.
Localisation d'éléments d'interface utilisateur (WebElements)
La localisation d'éléments dans WebDriver peut être effectuée sur l'instance WebDriver elle-même ou sur un WebElement.
Chacune des liaisons de langue expose une méthode «Trouver élément» et «Trouver des éléments». L'ancien retour
un objet WebElement correspondant à la requête et lève une exception si un tel élément est introuvable.
Ce dernier renvoie une liste de WebElements, éventuellement vide si aucun élément DOM ne correspond à la requête.
Les méthodes "Rechercher" prennent un objet de requête ou de localisateur appelé "Par". Les stratégies «par» sont énumérées ci-dessous.
Par ID
C'est le moyen le plus efficace et préféré de localiser un élément. Pièges courants que les développeurs d'interface utilisateur
make est d'avoir des identifiants non uniques sur une page ou de générer automatiquement l'identifiant, les deux doivent être évités. Une classe
sur un élément html est plus approprié qu'un identifiant généré automatiquement.
Exemple de recherche d'un élément ressemblant à ceci:
<div identifiant="coolestWidgetEvah">...</div>
WebElement élément = chauffeur.findElement(Par.identifiant("coolestWidgetEvah"));
IWebElement élément = chauffeur.FindElement(Par.Id("coolestWidgetEvah"));
élément = chauffeur.find_element(: id, "coolestWidgetEvah")
élément = chauffeur.find_element_by_id("coolestWidgetEvah")
ou
de selenium.webdriver.common.by importation Par
élément = chauffeur.find_element(par=Par.ID, valeur="coolestWidgetEvah")
élément $ = conducteur $->find_element('coolestWidgetEvah','id')
var élément = chauffeur.findElement(Par.identifiant('coolestWidgetEvah'));
Par nom de classe
“Classe” dans ce cas fait référence à l'attribut sur l'élément DOM. Souvent, dans la pratique, il y a
de nombreux éléments DOM avec le même nom de classe, la recherche de plusieurs éléments devient alors la solution la plus pratique.
option sur la recherche du premier élément.
Exemple de recherche d'un élément ressemblant à ceci:
<div classe="fromage"> <envergure>Cheddar</envergure> </div> <div classe="fromage"> <envergure>Gouda</envergure> </div>
liste<WebElement> les fromages = chauffeur.findElements(Par.nom du cours("fromage"));
IListe<IWebElement> les fromages = chauffeur.FindElements(Par.Nom du cours("fromage"));
les fromages = chauffeur.find_elements(:nom du cours, "fromage")
ou
les fromages = chauffeur.find_elements(:classe, "fromage")
les fromages = chauffeur.find_elements_by_class_name("fromage")
ou
de selenium.webdriver.common.by importation Par
les fromages = chauffeur.find_elements(Par.NOM DU COURS, "fromage")
@les fromages = conducteur $->find_elements('fromage', 'classe')
chauffeur.findElements(Par.nom du cours("fromage"))
.puis(les fromages => console.bûche(les fromages.longueur));
Par nom de tag
Le nom de la balise DOM de l'élément.
Exemple de recherche d'un élément ressemblant à ceci:
<iframe src="..."> </iframe>
WebElement Cadre = chauffeur.findElement(Par.tagName("iframe"));
IWebElement Cadre = chauffeur.FindElement(Par.TagName("iframe"));
Cadre = chauffeur.find_element(: tag_name, "iframe")
Cadre = chauffeur.find_element_by_tag_name("iframe")
ou
de selenium.webdriver.common.by importation Par
Cadre = chauffeur.find_element(Par.TAG_NAME, "iframe")
$ frame = conducteur $->find_element('iframe', 'tag_name')
var Cadre = chauffeur.findElement(Par.tagName('iframe'));
De nom
Recherchez l'élément d'entrée avec l'attribut name correspondant.
Exemple de recherche d'un élément ressemblant à ceci:
<contribution prénom="fromage" type="texte"/>
WebElement fromage = chauffeur.findElement(Par.prénom("fromage"));
IWebElement fromage = chauffeur.FindElement(Par.prénom("fromage"));
fromage = chauffeur.find_element(:prénom, "fromage")
fromage = chauffeur.find_element_by_name("fromage")
ou
de selenium.webdriver.common.by importation Par
fromage = chauffeur.find_element(Par.PRÉNOM, "fromage")
$ fromage = conducteur $->find_element('fromage', 'prénom')
var fromage = chauffeur.findElement(Par.prénom('fromage'));
Par lien texte
Recherchez l'élément de lien avec le texte visible correspondant.
Exemple de recherche d'un élément ressemblant à ceci:
<une href="http://www.google.com/search?q=cheese">fromage</une>>
WebElement fromage = chauffeur.findElement(Par.linkText("fromage"));
IWebElement fromage = chauffeur.FindElement(Par.LinkText("fromage"));
fromage = chauffeur.find_element(: link_text, "fromage")
ou
fromage = chauffeur.find_element(:lien, "fromage")
fromage = chauffeur.find_element_by_link_text("fromage")
ou
de selenium.webdriver.common.by importation Par
fromage = chauffeur.find_element(Par.LINK_TEXT, "fromage")
$ fromage = conducteur $->find_element('fromage', 'link_text')
var fromage = chauffeur.findElement(Par.linkText('fromage'));
Par texte de lien partiel
Recherchez l'élément de lien avec du texte visible correspondant partiellement.
Exemple de recherche d'un élément ressemblant à ceci:
<une href="http://www.google.com/search?q=cheese">recherche de fromage</une>>
WebElement fromage = chauffeur.findElement(Par.partialLinkText("fromage"));
IWebElement fromage = chauffeur.FindElement(Par.PartialLinkText("fromage"));
fromage = chauffeur.find_element(: partial_link_text, "fromage")
fromage = chauffeur.find_element_by_partial_link_text("fromage")
ou
de selenium.webdriver.common.by importation Par
fromage = chauffeur.find_element(Par.PARTIAL_LINK_TEXT, "fromage")
$ fromage = conducteur $->find_element('fromage', 'partial_link_text')
var fromage = chauffeur.findElement(Par.partialLinkText('fromage'));
Par CSS
Comme son nom l'indique, il s'agit d'une stratégie de localisation par css. Prise en charge du navigateur natif
est utilisé par défaut, veuillez donc vous référer aux sélecteurs CSS de w3c pour obtenir une liste des sélecteurs CSS disponibles. Si un navigateur n'a pas
support natif pour les requêtes css, alors Sizzle est utilisé. IE 6,7 et FF3,0
utilise actuellement Sizzle comme moteur de requête css.
Attention, tous les navigateurs n'ont pas été créés égaux. Certains CSS pouvant fonctionner dans une version peuvent ne pas fonctionner.
en autre.
Exemple de trouver le fromage ci-dessous:
<div identifiant="aliments"> <envergure classe="laitier">Lait</envergure> <envergure classe="laiterie vieillie">fromage</envergure> </div>
WebElement fromage = chauffeur.findElement(Par.cssSelector("#food span.dairy.aged"));
IWebElement fromage = chauffeur.FindElement(Par.CssSélecteur("#food span.dairy.aged"));
fromage = chauffeur.find_element(: css, "#food span.dairy.aged")
fromage = chauffeur.find_element_by_css_selector("#food span.dairy.aged")
ou
de selenium.webdriver.common.by importation Par
fromage = chauffeur.find_element(Par.CSS_SELECTOR, "#food span.dairy.aged")
$ fromage = conducteur $->find_element('#food span.dairy.aged', 'css')
var fromage = chauffeur.findElement(Par.css('#food span.dairy.aged'));
Par XPath
À un niveau élevé, WebDriver utilise les fonctionnalités XPath natives d’un navigateur partout
possible. Sur les navigateurs qui ne prennent pas en charge XPath en natif, nous avons
fourni notre propre mise en œuvre. Cela peut conduire à un comportement inattendu
à moins que vous ne connaissiez les différences entre les différents moteurs XPath.
Ceci est un petit résumé, donc pour le morceau de HTML suivant:
<contribution type="texte" prénom="Exemple" />
<CONTRIBUTION type="texte" prénom="autre" />
liste<WebElement> contributions = chauffeur.findElements(Par.xpath("//contribution"));
IListe<IWebElement> contributions = chauffeur.FindElements(Par.XPath("//contribution"));
contributions = chauffeur.find_elements(: xpath, "//contribution")
contributions = chauffeur.find_elements_by_xpath("//contribution")
ou
de selenium.webdriver.common.by importation Par
contributions = chauffeur.find_elements(Par.XPATH, "//contribution")
@contributions = conducteur $->find_elements('//contribution')
chauffeur.findElements(Par.xpath("//contribution"))
.puis(les fromages => console.bûche(les fromages.longueur));
Le nombre de correspondances suivantes sera trouvé
Parfois, les éléments HTML n'ont pas besoin d'attributs pour être explicitement déclarés
parce qu'ils vont par défaut aux valeurs connues. Par exemple, la balise «input» ne
pas besoin de l’attribut «type» car il utilise par défaut «text». La règle de
pouce lorsque vous utilisez xpath dans WebDriver est que vous ne devrait pas attendez-vous à pouvoir
faire correspondre à ces attributs implicites.
Utiliser JavaScript
Vous pouvez exécuter du javascript arbitraire pour trouver un élément et tant que vous retournez un élément DOM,
il sera automatiquement converti en objet WebElement.
Exemple simple sur une page sur laquelle jQuery est chargé:
WebElement élément = (WebElement) ((JavascriptExecutor)chauffeur).executeScript("retour $ ('. fromage')[0]")
IWebElement élément = (IWebElement) ((IJavaScriptExecutor)chauffeur).ExecuteScript("retour $ ('. fromage')[0]")
élément = chauffeur.execute_script("retour $ ('. fromage')[0]")
élément = chauffeur.execute_script("retour $ ('. fromage')[0]")
élément = conducteur $->execute_script("retour $ ('. fromage')[0]")
Trouver tous les éléments d'entrée pour chaque étiquette sur une page:
liste<WebElement> Étiquettes = chauffeur.findElements(Par.tagName("étiquette"));
liste<WebElement> contributions = (liste<WebElement>) ((JavascriptExecutor)chauffeur).executeScript(
"var labels = arguments[0], entrées = []; pour (var i = 0; i <labels.length; i ++) " +
"inputs.push (document.getElementById (étiquettes[i].getAttribute ('for'))); retourne les entrées; ", Étiquettes)
IListe<IWebElement> Étiquettes = chauffeur.FindElements(Par.TagName("étiquette"));
IListe<IWebElement> contributions = (IListe<IWebElement>) ((IJavaScriptExecutor)chauffeur).ExecuteScript(
"var labels = arguments[0], entrées = []; pour (var i = 0; i <labels.length; i ++) " +
"inputs.push (document.getElementById (étiquettes[i].getAttribute ('for'))); retourne les entrées; ", Étiquettes)
Étiquettes = chauffeur.find_elements(: tag_name, "étiquette")
contributions = chauffeur.execute_script(
"var labels = arguments[0], entrées = []; pour (var i = 0; i <labels.length; i ++) " +
"inputs.push (document.getElementById (étiquettes[i].getAttribute ('for'))); retourne les entrées; ", Étiquettes)
Étiquettes = chauffeur.find_elements_by_tag_name("étiquette")
contributions = chauffeur.execute_script(
"var labels = arguments[0], entrées = []; pour (var i = 0; i <labels.length; i ++) " +
"inputs.push (document.getElementById (étiquettes[i].getAttribute ('for'))); retourne les entrées; ", Étiquettes)
mon @Étiquettes = conducteur $->find_elements('étiquette', 'tag_name')
mon $ entrées = conducteur $->execute_script("var labels = arguments, input = []; pour (var i = 0; i <labels.length; i ++) inputs.push (document.getElementById (labels[i].getAttribute ('for'))); retourne les entrées; ", @Étiquettes)
Obtenir des valeurs de texte
Les utilisateurs souhaitent souvent récupérer la valeur innerText contenue dans un élément. Cela renvoie une valeur de chaîne unique. Notez que cela ne fera que renvoyer le texte visible affiché sur la page.
WebElement élément = chauffeur.findElement(Par.identifiant("elementID"));
élément.getText();
IWebElement élément = chauffeur.findElement(Par.identifiant("elementID"));
élément.Texte;
élément = chauffeur.find_element : id => "element_id"
élément.texte
élément = chauffeur.find_element_by_id("element_id")
élément.texte
var element = driver.findElement (By.id ('elementID'));
element.getText (). then (text => console.log (`Text is $ text`));
Entrée utilisateur – Remplir des formulaires
Nous avons déjà vu comment saisir du texte dans une zone de texte ou un champ de texte, mais
sur les autres éléments? Vous pouvez "basculer" l’état des cases à cocher, et vous
pouvez cliquer sur «cliquer» pour définir quelque chose comme une balise OPTION sélectionnée. Transaction
avec les balises SELECT n’est pas si mal:
WebElement sélectionner = chauffeur.findElement(Par.tagName("sélectionner"));
liste<WebElement> toutes les options = sélectionner.findElements(Par.tagName("option"));
pour (WebElement option : toutes les options)
Système.en dehors.imprimer(Chaîne.format("La valeur est:% s", option.obtenirAttribuer("valeur")));
option.Cliquez sur();
IWebElement sélectionner = chauffeur.FindElement(Par.TagName("sélectionner"));
IListe<IWebElement> toutes les options = sélectionner.FindElements(Par.TagName("option"));
pour chaque (IWebElement option dans toutes les options)
Console.WriteLine("La valeur est: " + option.GetAttribute("valeur"));
option.Cliquez sur();
sélectionner = chauffeur.find_element(: tag_name, "sélectionner")
toutes les options = sélectionner.find_elements(: tag_name, "option")
toutes les options.chaque faire |option|
met "La valeur est: " + option.attribut("valeur")
option.Cliquez sur
fin
sélectionner = chauffeur.find_element_by_tag_name("sélectionner")
toutes les options = sélectionner.find_elements_by_tag_name("option")
pour option dans toutes les options:
impression "La valeur est: " + option.get_attribute("valeur")
option.Cliquez sur()
$ select = conducteur $->find_element('sélectionner', 'tag_name')
@toutes les options = conducteur $->find_child_element($ select, "option", 'tag_name')
pour chaque option $ (@toutes les options)
impression "La valeur est: ".option $->get_attribute("valeur")." n";
option $->Cliquez sur();
Ceci trouvera le premier élément “SELECT” sur la page et parcourra chaque
à tour de rôle, en affichant leurs valeurs et en les sélectionnant à tour de rôle.
Comme vous le constaterez, ce n’est pas le moyen le plus efficace de traiter avec SELECT
éléments. Les classes de support de WebDriver comprennent une classe appelée «Select», qui
fournit des méthodes utiles pour interagir avec ceux-ci.
Sélectionner sélectionner = Nouveau Sélectionner(chauffeur.findElement(Par.tagName("sélectionner")));
sélectionner.tout déselectionner();
sélectionner.selectByVisibleText("Edam")
SelectElement sélectionner = Nouveau SelectElement(chauffeur.FindElement(Par.TagName("sélectionner")));
sélectionner.Tout déselectionner();
sélectionner.SelectByText("Edam")
# disponible depuis 2.14
sélectionner = Sélénium::WebDriver::Soutien::Sélectionner.Nouveau(chauffeur.find_element(: tag_name, "sélectionner"))
sélectionner.tout déselectionner()
sélectionner.select_by(:texte, "Edam")
# disponible depuis 2.12
de selenium.webdriver.support.ui importation Sélectionner
sélectionner = Sélectionner(chauffeur.find_element_by_tag_name("sélectionner"))
sélectionner.tout déselectionner()
sélectionner.select_by_visible_text("Edam")
Ceci désélectionnera toutes les OPTIONS du premier SELECT sur la page, puis
sélectionnez l'OPTION avec le texte affiché «Edam».
Une fois le formulaire rempli, vous souhaiterez probablement le soumettre. Un
Pour ce faire, recherchez le bouton «Soumettre» et cliquez dessus:
chauffeur.findElement(Par.identifiant("soumettre")).Cliquez sur();
chauffeur.FindElement(Par.Id("soumettre")).Cliquez sur();
chauffeur.find_element(: id, "soumettre").Cliquez sur
chauffeur.find_element_by_id("soumettre").Cliquez sur()
conducteur $->find_element('soumettre','id')->Cliquez sur()
chauffeur.findElement(Par.identifiant('soumettre').Cliquez sur();
WebDriver a aussi la méthode de commodité «submit» sur chaque élément.
Si vous appelez cela sur un élément du formulaire, WebDriver remontera le DOM.
jusqu'à ce qu'il trouve le formulaire ci-joint et appelle ensuite soumettre à ce sujet. Si la
l’élément n’est pas dans un formulaire, alors le NoSuchElementException sera jeté:
Se déplacer entre Windows et les cadres
Certaines applications Web ont plusieurs cadres ou plusieurs fenêtres. WebDriver prend en charge
vous déplacer entre les fenêtres nommées en utilisant la méthode «switchTo»:
chauffeur.basculer vers()la fenêtre("windowName")
chauffeur.Basculer vers()La fenêtre("windowName")
chauffeur.basculer vers.la fenêtre("windowName")
chauffeur.basculer vers.la fenêtre("windowName")
conducteur $->switch_to_window("windowName")
chauffeur.basculer vers()la fenêtre('windowName')
Tous les appels à chauffeur sera maintenant interprété comme étant dirigé vers le
fenêtre particulière. Mais comment connaissez-vous le nom de la fenêtre? Regardez le
javascript ou lien qui l'a ouvert:
<une href="quelque part.html" cible="windowName">Cliquez ici pour ouvrir une nouvelle fenêtre</une>
Alternativement, vous pouvez passer un "handle de fenêtre" à "switchTo (). Window ()"
méthode. Sachant cela, il est possible de parcourir toutes les fenêtres ouvertes comme ceci:
pour (Chaîne manipuler : chauffeur.getWindowHandles())
chauffeur.basculer vers()la fenêtre(manipuler)
pour chaque (chaîne manipuler dans chauffeur.Poignées de fenêtre)
chauffeur.Basculer vers()La fenêtre(manipuler)
chauffeur.window_handles.chaque faire |manipuler|
chauffeur.switch_to.la fenêtre manipuler
fin
pour manipuler dans chauffeur.window_handles:
chauffeur.switch_to.la fenêtre(manipuler)
$windows = $driver->get_window_handles()
foreach $window (@$windows)
$driver->switch_to_window($window)
You can also switch from frame to frame (or into iframes):
chauffeur.switchTo().Cadre("frameName")
chauffeur.SwitchTo().Cadre("frameName")
chauffeur.switch_to.Cadre "frameName"
chauffeur.switch_to.Cadre("frameName")
$driver->switch_to_frame('frameName')
chauffeur.switchTo().Cadre('frameName')
Cookies
Before we leave these next steps, you may be interested in understanding how to
use cookies. First of all, you need to be on the domain that the cookie will be
valid for. If you are trying to preset cookies before
you start interacting with a site and your homepage is large / takes a while to load
an alternative is to find a smaller page on the site (typically the 404 page is small,
par exemple. http://example.com/some404page).
// Go to the correct domain
chauffeur.obtenir("http://www.example.com")
// Now set the cookie. This one's valid for the entire domain
Biscuit biscuit = Nouveau Biscuit("key", "value")
chauffeur.gérer().addCookie(biscuit)
// And now output all the available cookies for the current URL
Ensemble<Biscuit> allCookies = chauffeur.gérer().getCookies();
pour (Biscuit loadedCookie : allCookies)
Système.en dehors.imprimer(Chaîne.format("%s -> %s", loadedCookie.getName(), loadedCookie.getValue()));
// You can delete cookies in 3 ways
// By name
chauffeur.gérer().deleteCookieNamed("CookieName")
// By Cookie
chauffeur.gérer().deleteCookie(loadedCookie)
// Or all of them
chauffeur.gérer().deleteAllCookies();
# Go to the correct domain
chauffeur.obtenir("http://www.example.com")
# Now set the cookie. Here's one for the entire domain
# the cookie name here is 'key' and its value is 'value'
chauffeur.add_cookie('name':'key', 'value':'value', 'path':'/')
# additional keys that can be passed in are:
# 'domain' -> String,
# 'secure' -> Boolean,
# 'expiry' -> Milliseconds since the Epoch it should expire.
# And now output all the available cookies for the current URL
pour biscuit dans chauffeur.get_cookies():
impression "% s -> % s" % (biscuit[[[['name'], biscuit[[[['value'])
# You can delete cookies in 2 ways
# By name
chauffeur.delete_cookie("CookieName")
# Or all of them
chauffeur.delete_all_cookies()
# Go to the correct domain
chauffeur.obtenir "http://www.example.com"
# Now set the cookie. Here's one for the entire domain
# the cookie name here is 'key' and its value is 'value'
chauffeur.gérer.add_cookie(:name => 'key', :value => 'value')
# additional keys that can be passed in are:
# :path => String, :secure -> Boolean, :expires -> Time, DateTime, or seconds since epoch
# And now output all the available cookies for the current URL
chauffeur.gérer.all_cookies.chaque
met "#biscuit[[[[:name] => #biscuit[[[[:value]"
# You can delete cookies in 2 ways
# By name
chauffeur.gérer.delete_cookie "CookieName"
# Or all of them
chauffeur.gérer.delete_all_cookies
# Go to the correct domain
$driver->obtenir("http://www.example.com")
# Now set the cookie. Here's one for the entire domain
# the cookie name here is 'key' and its value is 'value'
$driver->add_cookie('key', 'value', '/', 'example.com', 0)
# additional required inputs are path and domain
# the final input secure is an optional boolean
# And now output all the available cookies for the current URL
mon $cookies_ref = $driver->get_all_cookies(); # Returns reference to AoH
pour $cookie_ref (@$cookies_ref)
printf "%s => %sn", $cookie_ref->prénom, $cookie_ref->valeur;
# You can delete cookies in 2 ways
# By name
$driver->delete_cookie_named("key")
# Or all of them
$driver->delete_all_cookies();
# Go to the correct domain
driver.get('http://www.example.com');
# Now set the basic cookie. Here's one for the entire domain
# the cookie name here is 'key' and its value is 'value'
driver.manage().addCookie(name: 'cookie-1', value: 'cookieValue');
# And now output all the available cookies for the current URL
driver.manage().getCookies().then( (loadedCookies) =>
for (let cookie in loadedCookies)
console.log('printing Cookies loaded : '+cookie);
);
# You can delete cookies in 2 ways
# By name
driver.manage().deleteCookie('cookie-1');
# Or all of them
driver.manage().deleteAllCookies();
Changing the User Agent
This is easy with the Firefox Driver:
FirefoxProfile profil = Nouveau FirefoxProfile();
profil.addAdditionalPreference("general.useragent.override", "some UA string")
WebDriver chauffeur = Nouveau FirefoxDriver(profil)
var profil = Nouveau FirefoxProfile();
profil.SetPreference("general.useragent.override", "some UA string")
IWebDriver chauffeur = Nouveau FirefoxDriver(profil)
profil = Sélénium::WebDriver::Firefox::Profil.Nouveau
profil[[[['general.useragent.override'] = "some UA string"
chauffeur = Sélénium::WebDriver.pour :firefox, :profile => profil
profil = webdriver.FirefoxProfile()
profil.set_preference("general.useragent.override", "some UA string")
chauffeur = webdriver.Firefox(profil)
utilisation Selenium::Remote::Driver::Firefox::Profile;
mon $profile = Selenium::Remote::Driver::Firefox::Profile->Nouveau;
$profile->set_preference('general.useragent.overide' => "some UA string")
mon $driver = Selenium::Remote::Driver->Nouveau('firefox_profile' => $profile)
Drag And Drop
Here’s an example of using the Actions class to perform a drag and drop.
Native events are required to be enabled.
WebElement élément = chauffeur.findElement(Par.prénom("source"));
WebElement cible = chauffeur.findElement(Par.prénom("target"));
(Nouveau actes(chauffeur)).dragAndDrop(élément, cible).effectuer();
IWebElement élément = chauffeur.FindElement(Par.prénom("source"));
IWebElement cible = chauffeur.FindElement(Par.prénom("target"));
(Nouveau actes(chauffeur)).DragAndDrop(élément, cible).Effectuer();
élément = chauffeur.find_element(:name => 'source')
cible = chauffeur.find_element(:name => 'target')
chauffeur.action.drag_and_drop(élément, cible).effectuer
de selenium.webdriver.common.action_chains importation ActionChains
élément = chauffeur.find_element_by_name("source")
cible = chauffeur.find_element_by_name("target")
ActionChains(chauffeur).drag_and_drop(élément, cible).effectuer()
Driver Specifics and Tradeoffs
Selenium-WebDriver’s Drivers
WebDriver is the name of the key interface against which tests should be
written, but there are several implementations. Ceux-ci inclus:
HtmlUnit Driver
This is currently the fastest and most lightweight implementation of WebDriver.
As the name suggests, this is based on HtmlUnit. HtmlUnit is a java based implementation
of a WebBrowser without a GUI. For any language binding (other than java) the
Selenium Server is required to use this driver.
Usage
WebDriver chauffeur = Nouveau HtmlUnitDriver();
IWebDriver chauffeur = Nouveau RemoteWebDriver(Nouveau Uri("http://127.0.0.1:4444/wd/hub"),
DesiredCapabilities.HtmlUnit());
chauffeur = webdriver.Remote("http://localhost:4444/wd/hub", webdriver.DesiredCapabilities.HTMLUNIT.copie())
chauffeur = Sélénium::WebDriver.pour :remote, :url => "http://localhost:4444/wd/hub", :desired_capabilities => :htmlunit
mon $driver = Selenium::Remote::Driver->Nouveau(browser_name => 'htmlunit', remote_server_addr => 'localhost', Port => '4444')
Avantages
- Fastest implementation of WebDriver
- A pure Java solution and so it is platform independent.
- Supports JavaScript
Les inconvénients
- Emulates other browsers’ JavaScript behaviour (see below)
JavaScript in the HtmlUnit Driver
None of the popular browsers uses the JavaScript engine used by HtmlUnit
(Rhino). If you test JavaScript using HtmlUnit the results may differ
significantly from those browsers.
When we say “JavaScript” we actually mean “JavaScript and the DOM”. Although
the DOM is defined by the W3C each browser has its own quirks and differences
in their implementation of the DOM and in how JavaScript interacts with it.
HtmlUnit has an impressively complete implementation of the DOM and has good
support for using JavaScript, but it is no different from any other
browser: it has its own quirks and differences from both the W3C standard and
the DOM implementations of the major browsers, despite its ability to mimic
other browsers.
With WebDriver, we had to make a choice; do we enable HtmlUnit’s JavaScript
capabilities and run the risk of teams running into problems that only manifest
themselves there, or do we leave JavaScript disabled, knowing that there are
more and more sites that rely on JavaScript? We took the conservative approach,
and by default have disabled support when we use HtmlUnit. With each release of
both WebDriver and HtmlUnit, we reassess this decision: we hope to enable
JavaScript by default on the HtmlUnit at some point.
Enabling JavaScript
If you can’t wait, enabling JavaScript support is very easy:
HtmlUnitDriver chauffeur = Nouveau HtmlUnitDriver(vrai)
WebDriver chauffeur = Nouveau RemoteWebDriver(Nouveau Uri("http://127.0.0.1:4444/wd/hub"),
DesiredCapabilities.HtmlUnitWithJavaScript());
casquettes = Sélénium::WebDriver::Remote::Les capacités.htmlunit(:javascript_enabled => vrai)
chauffeur = Sélénium::WebDriver.pour :remote, :url => "http://localhost:4444/wd/hub", :desired_capabilities => casquettes
chauffeur = webdriver.Remote("http://localhost:4444/wd/hub", webdriver.DesiredCapabilities.HTMLUNITWITHJS)
$driver = Nouveau Selenium::Remote::Driver( browser_name=>'firefox', Port=> 4444, version=>'', Plate-forme=>'LINUX', javascript=>1, auto_close=>1)
This will cause the HtmlUnit Driver to emulate Firefox 3.6’s JavaScript
handling by default.
Firefox Driver
Controls the Firefox browser using a Firefox plugin.
The Firefox Profile that is used is stripped down from what is installed on the
machine to only include the Selenium WebDriver.xpi (plugin). A few settings are
also changed by default (see the source to see which ones)
Firefox Driver is capable of being run and is tested on Windows, Mac, Linux.
Currently on versions 3.6, 10, latest – 1, latest
Usage
WebDriver chauffeur = Nouveau FirefoxDriver();
IWebDriver chauffeur = Nouveau FirefoxDriver();
chauffeur = webdriver.Firefox()
chauffeur = Sélénium::WebDriver.pour :firefox
mon $driver = Selenium::Remote::Driver->Nouveau;
Modifying the Firefox Profile
Suppose that you wanted to modify the user agent string (as above), but you’ve
got a tricked out Firefox profile that contains dozens of useful extensions.
There are two ways to obtain this profile. Assuming that the profile has been
created using Firefox’s profile manager (firefox -ProfileManager):
ProfilesIni allProfiles = Nouveau ProfilesIni();
FirefoxProfile profil = allProfiles.getProfile("WebDriver")
profil.setPreferences("foo.bar", 23)
WebDriver chauffeur = Nouveau FirefoxDriver(profil)
var profileManager = Nouveau FirefoxProfileManager();
FirefoxProfile profil = profileManager.GetProfile("WebDriver")
profil.SetPreference("foo.bar", 23)
IWebDriver chauffeur = Nouveau FirefoxDriver(profil)
Alternatively, if the profile isn’t already registered with Firefox:
File profileDir = Nouveau File("path/to/top/level/of/profile")
FirefoxProfile profil = Nouveau FirefoxProfile(profileDir)
profil.addAdditionalPreferences(extraPrefs)
WebDriver chauffeur = Nouveau FirefoxDriver(profil)
FirefoxProfile profil = Nouveau FirefoxProfile("path/to/top/level/of/profile")
profil.SetPreference("extra", "pref")
IWebDriver chauffeur = Nouveau FirefoxDriver(profil)
As we develop features in the Firefox Driver, we expose the ability to use them.
For example, until we feel native events are stable on Firefox for Linux, they
are disabled by default. To enable them:
FirefoxProfile profil = Nouveau FirefoxProfile();
profil.setEnableNativeEvents(vrai)
WebDriver chauffeur = Nouveau FirefoxDriver(profil)
var profil = Nouveau FirefoxProfile EnableNativeEvents = vrai;
IWebDriver chauffeur = Nouveau FirefoxDriver(profil)
profil = webdriver.FirefoxProfile()
profil.native_events_enabled = Vrai
chauffeur = webdriver.Firefox(profil)
profil = Sélénium::WebDriver::Firefox::Profil.Nouveau
profil.native_events = vrai
chauffeur = Sélénium::WebDriver.pour :firefox, :profile => profil
Internet Explorer Driver
The InternetExplorerDriver is a standalone server which implements WebDriver’s wire protocol. This driver has been tested with IE 7, 8, 9, 10, and 11 on appropriate combinations of Vista, Windows 7, Windows 8, and Windows 8.1. As of 15 April 2014, IE 6 is no longer supported.
The driver supports running 32-bit and 64-bit versions of the browser. The choice of how to determine which “bit-ness” to use in launching the browser depends on which version of the IEDriverServer.exe is launched. If the 32-bit version of IEDriverServer.exe is launched, the 32-bit version of IE will be launched. Similarly, if the 64-bit version of IEDriverServer.exe is launched, the 64-bit version of IE will be launched.
Usage
WebDriver chauffeur = Nouveau InternetExplorerDriver();
IWebDriver chauffeur = Nouveau InternetExlorerDriver();
chauffeur = Sélénium::WebDriver.pour :ie
mon $driver = Selenium::Remote::Driver->Nouveau(browser_name => 'internet explorer')
Avantages
- Runs in a real browser and supports Javascript
Les inconvénients
- Obviously the InternetExplorerDriver will only work on Windows!
- Comparatively slow (though still pretty snappy!)
ChromeDriver
ChromeDriver is maintained / supported by the Chromium
project iteslf. WebDriver works with Chrome through the chromedriver binary (found on the chromium
project’s download page). You need to have both chromedriver and a version of chrome browser installed.
chromedriver needs to be placed somewhere on your system’s path in order for WebDriver to automatically
discover it. The Chrome browser itself is discovered by chromedriver in the default installation path.
These both can be overridden by environment variables. Please refer to the wiki
for more information.
Usage
WebDriver chauffeur = Nouveau ChromeDriver();
IWebDriver chauffeur = Nouveau ChromeDriver();
chauffeur = webdriver.Chrome()
chauffeur = Sélénium::WebDriver.pour :chrome
mon $driver = Selenium::Remote::Driver->Nouveau(browser_name => 'chrome')
Avantages
- Runs in a real browser and supports JavaScript
- Because Chrome is a Webkit-based browser, the ChromeDriver may allow you to
verify that your site works in Safari. Note that since Chrome uses its own V8
JavaScript engine rather than Safari’s Nitro engine, JavaScript execution may
differ.
Alternative Back-Ends: Mixing WebDriver and RC Technologies
WebDriver-Backed Selenium-RC
The Java version of WebDriver provides an implementation of the Selenium-RC API. These means that
you can use the underlying WebDriver technology using the Selenium-RC API. This is primarily
provided for backwards compatibility. It allows those who have existing test suites using the
Selenium-RC API to use WebDriver under the covers. It’s provided to help ease the migration path
to Selenium-WebDriver. Also, this allows one to use both APIs, side-by-side, in the same test code.
Selenium-WebDriver is used like this:
// You may use any WebDriver implementation. Firefox is used here as an example
WebDriver chauffeur = Nouveau FirefoxDriver();
// A "base url", used by selenium to resolve relative URLs
Chaîne baseUrl = "http://www.google.com";
// Create the Selenium implementation
Sélénium sélénium = Nouveau WebDriverBackedSelenium(chauffeur, baseUrl)
// Perform actions with selenium
sélénium.ouvrir("http://www.google.com")
sélénium.type("name=q", "cheese")
sélénium.Cliquez sur("name=btnG")
// Get the underlying WebDriver implementation back. This will refer to the
// same WebDriver instance as the "driver" variable above.
WebDriver driverInstance = ((WebDriverBackedSelenium) sélénium).getWrappedDriver();
//Finally, close the browser. Call stop on the WebDriverBackedSelenium instance
//instead of calling driver.quit(). Otherwise, the JVM will continue running after
//the browser has been closed.
sélénium.Arrêtez();
Avantages
- Allows for the WebDriver and Selenium APIs to live side-by-side
- Provides a simple mechanism for a managed migration from the Selenium RC API
to WebDriver’s - Does not require the standalone Selenium RC server to be run
Les inconvénients
- Does not implement every method
- More advanced Selenium usage (using “browserbot” or other built-in JavaScript
methods from Selenium Core) may not work - Some methods may be slower due to underlying implementation differences
Backing WebDriver with Selenium
WebDriver doesn’t support as many browsers as Selenium RC does, so in order to
provide that support while still using the WebDriver API, you can make use of
la SeleneseCommandExecutor
Safari is supported in this way with the following code (be sure to disable
pop-up blocking):
DesiredCapabilities capacités = Nouveau DesiredCapabilities();
capacités.setBrowserName("safari")
CommandExecutor executor = Nouveau SeleneseCommandExecutor(Nouveau URL("http://localhost:4444/"), Nouveau URL("http://www.google.com/"), capacités)
WebDriver chauffeur = Nouveau RemoteWebDriver(executor, capacités)
There are currently some major limitations with this approach, notably that
findElements doesn’t work as expected. Also, because we’re using Selenium Core
for the heavy lifting of driving the browser, you are limited by the JavaScript
sandbox.
Running Standalone Selenium Server for use with RemoteDrivers
From Selenium’s Download page download selenium-server-standalone-
Unpack IEDriverServer and/or chromedriver and put them in a directory which is on the $PATH / %PATH% – the Selenium Server should then be able to handle requests for IE / Chrome without additional modifications.
Start the server on the command line with
java -jar /selenium-server-standalone-.pot
If you want to use native events functionality, indicate this on the command line with the option
-Dwebdriver.enable.native.events=1
For other command line options, execute
java -jar /selenium-server-standalone-.jar -help
In order to function properly, the following ports should be allowed incoming TCP connections: 4444, 7054-5 (or twice as many ports as the number of concurrent instances you plan to run). Under Windows, you may need to unblock the applications as well.
Ressources supplémentaires
You can find further resources for WebDriver
in WebDriver’s wiki
Of course, don’t hesitate to do an internet search on any Selenium topic, including
Selenium-WebDriver’s drivers. There are quite a few blogs on Selenium along with numerous posts
on various user forums. Additionally the Selenium User’s Group is a great resource.
http://groups.google.com/group/selenium-users
Prochaines étapes
This chapter has simply been a high level walkthrough of WebDriver and some of its key
capabilities. Once getting familiar with the Selenium-WebDriver API you will then want to learn
how to build test suites for maintainability, extensibility, and reduced fragility when features of
the AUT frequently change. The approach most Selenium experts are now recommending is to design
your test code using the Page Object Design Pattern along with possibly a Page Factory.
Selenium-WebDriver provides support for this by supplying a PageFactory class in Java and C#.
This is presented, along with other advanced topics, in the
Chapitre suivant. Also, for high-level description of this
technique, you may want to look at the
Test Design Considerations chapter. Both of these
chapters present techniques for writing more maintainable tests by making your test code more
modular.
Commentaires
Laisser un commentaire