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.

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"> 4.0.0 MySel20Proj MySel20Proj 1,0 org.seleniumhq.selenium sélénium-serveur 3.0.1

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')

Navigation: History and Location Earlier, we covered navigating to a page using the “get” command ( driver.get("http://www.example.com") ou driver.Url="http://www.example.com" in C#). As you’ve seen, WebDriver has a number of smaller, task-focused interfaces, and navigation is a useful task. Because loading a page is such a fundamental requirement, the method to do this lives on the main WebDriver interface, but it’s simply a synonym to:

chauffeur.naviguer().à("http://www.example.com")

chauffeur.Navigate().GoToUrl("http://www.example.com")

chauffeur.naviguer.à "http://www.example.com"

chauffeur.obtenir("http://www.example.com") # python doesn't have driver.navigate

$driver->naviguer('http://www.example.com')

chauffeur.naviguer().à('http://www.example.com')

To reiterate: “navigate().to()" et "get()” do exactly the same thing. One’s just a lot easier to type than the other! The “navigate” interface also exposes the ability to move backwards and forwards in your browser’s history:

chauffeur.naviguer().vers l'avant(); chauffeur.naviguer().retour();

chauffeur.Navigate().Vers l'avant(); chauffeur.Navigate().Retour();

chauffeur.naviguer.vers l'avant chauffeur.naviguer.retour

chauffeur.vers l'avant() chauffeur.retour()

chauffeur.naviguer().vers l'avant(); chauffeur.naviguer().retour();

Please be aware that this functionality depends entirely on the underlying navigateur. It’s just possible that something unexpected may happen when you call these methods if you’re used to the behaviour of one browser over another.

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-.jar and optionally IEDriverServer. If you plan to work with Chrome, download it from Google Code. 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.

Click to rate this post! [Total: 0 Average: 0]