web-dev-qa-db-fra.com

Sélénium waitForElement

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.

pythonselenium-webdriverautomationautomated-tests
41
Breedly

À 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)
47
unutbu

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')
19
Dave Koo

J'ai fait de bonnes expériences en utilisant:

  • time.sleep (seconds)
  • webdriver.Firefox.implicitly_wait (secondes)

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.

7
naeg

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.

2
Deven Kalra

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.

1
jro

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")
1
jcfollower

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
1
John LeComte

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
1
TheDawg

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)
0
Ben

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)
0
Diego Orellana

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.

0
onder.diri