Comment est-ce que j'écris la fonction pour que Selenium attend une table avec juste un identifiant de classe en Python? J'ai du mal à apprendre à utiliser les fonctions de Webdriver Python de Selenium.
À partir de Selenium Documentation PDF :
import contextlib
import Selenium.webdriver as webdriver
import Selenium.webdriver.support.ui as ui
with contextlib.closing(webdriver.Firefox()) as driver:
driver.get('http://www.google.com')
wait = ui.WebDriverWait(driver,10)
# Do not call `implicitly_wait` if using `WebDriverWait`.
# It magnifies the timeout.
# driver.implicitly_wait(10)
inputElement=driver.find_element_by_name('q')
inputElement.send_keys('Cheese!')
inputElement.submit()
print(driver.title)
wait.until(lambda driver: driver.title.lower().startswith('cheese!'))
print(driver.title)
# This raises
# Selenium.common.exceptions.TimeoutException: Message: None
# after 10 seconds
wait.until(lambda driver: driver.find_element_by_id('someId'))
print(driver.title)
Les liaisons Python de Selenium 2 ont une nouvelle classe de support appelée attendu_conditions.py pour faire toutes sortes de choses, comme tester si un élément est visible. C'est disponible ici.
REMARQUE: le fichier ci-dessus est dans le coffre en date du 12 octobre 2012, mais pas encore dans le dernier téléchargement, à savoir 2,25. Jusqu'à la publication d'une nouvelle version de Selenium, vous pouvez simplement enregistrer ce fichier localement pour l'instant et l'inclure dans vos importations, comme je l'ai fait ci-dessous.
Pour simplifier un peu la vie, vous pouvez combiner certaines de ces méthodes de condition attendues avec la logique Selenium wait until
afin de créer des fonctions très pratiques similaires à celles disponibles dans Selenium 1. Par exemple, je les ai insérées dans ma classe de base appelée SeleniumTest. de mes classes de test de sélénium s'étendent:
from Selenium.common.exceptions import TimeoutException
from Selenium.webdriver.common.by import By
import Selenium.webdriver.support.expected_conditions as EC
import Selenium.webdriver.support.ui as ui
@classmethod
def setUpClass(cls):
cls.Selenium = WebDriver()
super(SeleniumTest, cls).setUpClass()
@classmethod
def tearDownClass(cls):
cls.Selenium.quit()
super(SeleniumTest, cls).tearDownClass()
# return True if element is visible within 2 seconds, otherwise False
def is_visible(self, locator, timeout=2):
try:
ui.WebDriverWait(driver, timeout).until(EC.visibility_of_element_located((By.CSS_SELECTOR, locator)))
return True
except TimeoutException:
return False
# return True if element is not visible within 2 seconds, otherwise False
def is_not_visible(self, locator, timeout=2):
try:
ui.WebDriverWait(driver, timeout).until_not(EC.visibility_of_element_located((By.CSS_SELECTOR, locator)))
return True
except TimeoutException:
return False
Vous pouvez ensuite les utiliser facilement dans vos tests, comme ceci:
def test_search_no_city_entered_then_city_selected(self):
sel = self.Selenium
sel.get('%s%s' % (self.live_server_url, '/'))
self.is_not_visible('#search-error')
J'ai fait de bonnes expériences en utilisant:
Le premier est assez évident - attendez quelques secondes pour quelques trucs.
Pour tous mes scripts Selenium, le sommeil () avec quelques secondes (plage allant de 1 à 3) fonctionne lorsque je les exécute sur mon ordinateur portable, mais sur mon serveur, le temps d'attente a une plage plus étendue, aussi j'utilise implicitement_wait (). J'utilise habituellement implicitly_wait (30), ce qui est vraiment suffisant.
Une attente implicite consiste à demander à WebDriver d'interroger le DOM pendant un certain temps lors de la recherche d'un ou de plusieurs éléments s'ils ne sont pas immédiatement disponibles. Le paramètre par défaut est 0. Une fois défini, l'attente implicite est définie pour la durée de vie de l'instance d'objet WebDriver.
J'ai implémenté ce qui suit pour python pour wait_for_condition car le pilote python Selenium ne prend pas en charge cette fonction.
def wait_for_condition(c):
for x in range(1,10):
print "Waiting for ajax: " + c
x = browser.execute_script("return " + c)
if(x):
return
time.sleep(1)
être utilisé comme
Attendez qu’un appel ExtJS Ajax n’est pas en attente:
wait_for_condition("!Ext.Ajax.isLoading()")
Une variable Javascript est définie
wait_for_condition("CG.discovery != undefined;")
etc.
Utilisez Wait Until Page Contains Element
avec le localisateur XPath approprié. Par exemple, étant donné le code HTML suivant:
<body>
<div id="myDiv">
<table class="myTable">
<!-- implementation -->
</table>
</div>
</body>
... vous pouvez entrer le mot clé suivant:
Wait Until Page Contains Element //table[@class='myTable'] 5 seconds
À moins que quelque chose ne me manque, il n'est pas nécessaire de créer une nouvelle fonction pour cela.
Au cas où cela aiderait ...
Dans l'IDE Selenium, j'ai ajouté ... Commande: waitForElementPresent Cible: // table [@ class = 'pln']
Ensuite, j'ai créé Fichier> Exporter TestCase en tant que Python2 (pilote Web), et cela m’a permis de ...
def test_sel(self):
driver = self.driver
for i in range(60):
try:
if self.is_element_present(By.XPATH, "//table[@class='pln']"): break
except: pass
time.sleep(1)
else: self.fail("time out")
Espérons que cela aide
from Selenium import webdriver
from Selenium.webdriver.support import expected_conditions as EC
from Selenium.webdriver.support.wait import WebDriverWait
from Selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.get('www.url.com')
try:
wait = driver.WebDriverWait(driver,10).until(EC.presence_of_element_located(By.CLASS_NAME,'x'))
except:
pass
Vous pouvez toujours utiliser un court sommeil dans une boucle et lui transmettre votre identifiant d'élément:
def wait_for_element(element):
count = 1
if(self.is_element_present(element)):
if(self.is_visible(element)):
return
else:
time.sleep(.1)
count = count + 1
else:
time.sleep(.1)
count = count + 1
if(count > 300):
print("Element %s not found" % element)
self.stop
#prevents infinite loop
solution plus facile:
from Selenium.webdriver.common.by import By
import time
while len(driver.find_elements(By.ID, 'cs-paginate-next'))==0:
time.sleep(100)
Vous pouvez modifier cette fonction pour tous les types d'éléments. Celui ci-dessous est juste pour l'élément de classe:
Où "driver" est le pilote, "nom_élément" est le nom de la classe que vous recherchez et "sec" est le nombre maximal de secondes que vous êtes prêt à attendre.
def wait_for_class_element(driver,element_name,sec):
for i in range(sec):
try:
driver.find_element_by_class_name(element_name)
break
except:
print("not yet")
time.sleep(1)
Si je ne connais pas la commande Selenium, j'utilise l'idée Web de Selenium avec Firefox. Vous pouvez choisir et ajouter une commande dans la liste déroulante et lorsque vous avez terminé votre scénario de test après avoir exporté le code de test dans une autre langue. comme Java, Ruby, Phyton, C #, etc.