Explication détaillée des trois méthodes d'attente de Selenium (attente forcée, attente implicite et attente explicite)

Préface

①Lors de l'exécution d'un travail d'automatisation WEB, il est généralement nécessaire d'attendre qu'un certain élément de page soit chargé avant d'effectuer des opérations sur l'élément, sinon le script d'automatisation générera une erreur indiquant que l'élément est introuvable, ce qui nous oblige à tester dans certains scénarios. des tests d’automatisation de l’interface utilisateur plus le temps d’attente.

②Le réglage du mode d'attente est un moyen très important pour garantir le fonctionnement stable et efficace des scripts automatisés.

Attente forcée pour dormir()

① Forcez l'attente et définissez une heure de sommeil fixe.

②Le package time de Python fournit la méthode sleep sleep(); après avoir importé le package time, vous pouvez utiliser sleep() pour dormir pendant l'exécution du script.

le code s'affiche comme ci-dessous :

# coding = utf-8
from time import sleep
from selenium import webdriver

# 驱动文件路径
driverfile_path = r'D:\coship\Test_Framework\drivers\chromedriver.exe'
# 启动浏览器
driver = webdriver.Chrome(executable_path=driverfile_path)
# 打开百度首页
driver.get(r'https://www.baidu.com/')
# 等待3秒
sleep(3)
driver.find_element_by_css_selector("#kw").send_keys("selenium")
# 退出
driver.quit()

Attendre implicitement driver.implicitly_wait(time)

①C'est l'équivalent d' une attente globale.Définir un délai d'attente pour tous les éléments lors du positionnement d'un élément .

②Définissez un temps d'attente. Si la page Web est chargée pendant ce temps d'attente, exécutez l'étape suivante ; sinon, attendez que le délai expire, puis exécutez l'étape suivante. Cela aura également un inconvénient, le programme attendra que la page entière se charge jusqu'à expiration, mais parfois l'élément dont j'ai besoin a déjà été chargé, mais il y a d'autres éléments sur la page qui se chargent très lentement, et je continue il faut attendre la page. L'étape suivante ne peut être effectuée qu'une fois tous les chargements terminés.

③L'attente implicite oblige WebDriver à interroger le DOM à intervalles réguliers lors de la recherche d'un tableau Element ou Elements, si le tableau Element ou Elements n'est pas trouvé immédiatement. Le paramètre par défaut est 0. Une fois définie, cette attente implicite fonctionnera pendant toute la durée de vie de l'instance d'objet WebDriver.

# coding = utf-8
from selenium import webdriver

# 驱动文件路径
driverfile_path = r'D:\coship\Test_Framework\drivers\chromedriver.exe'
# 启动浏览器
driver = webdriver.Chrome(executable_path=driverfile_path)
# 打开百度首页
driver.get(r'https://www.baidu.com/')
driver.find_element_by_css_selector("#kw").send_keys("selenium")
driver.find_element_by_css_selector("#su").click()
# 隐式等待30秒
driver.implicitly_wait(30)
result = driver.find_elements_by_css_selector("h3.t>a")
for i in result:
    print(i.text)
# 退出
driver.quit()

现在我也找了很多测试的朋友，做了一个分享技术的交流群，共享了很多我们收集的技术文档和视频教程。
如果你不想再体验自学时找不到资源，没人解答问题，坚持几天便放弃的感受
可以加入我们一起交流。而且还有很多在自动化，性能，安全，测试开发等等方面有一定建树的技术大牛
分享他们的经验，还会分享很多直播讲座和技术沙龙
可以免费学习！划重点！开源的！！！
qq群号：110685036

montrer, attendre

① Nous avons évoqué ci-dessus l'un des inconvénients de l'attente implicite : que se passe-t-il si je veux attendre que l'élément que je souhaite charger avant d'exécuter l'étape suivante ? L'attente d'affichage est utilisée ici .

② L'attente explicite est un morceau de code que vous définissez pour attendre qu'une certaine condition se produise avant de continuer à exécuter le code suivant.

③Pendant  le temps défini, par défaut, vérifiez si l'élément de page actuel existe de temps en temps et lancez une exception s'il ne peut pas être détecté au-delà du temps défini . La fréquence de détection par défaut est de 0,5 s et l'exception par défaut levée est : NoSuchElementException  .

④ Documentation d'aide pour WebDriverWait :

>>> help(WebDriverWait)
Help on class WebDriverWait in module selenium.webdriver.support.wait:

class WebDriverWait(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self, driver, timeout, poll_frequency=0.5, ignored_exceptions=None)
 |      Constructor, takes a WebDriver instance and timeout in seconds.
 |
 |      :Args:
 |       - driver - Instance of WebDriver (Ie, Firefox, Chrome or Remote)
 |       - timeout - Number of seconds before timing out
 |       - poll_frequency - sleep interval between calls
 |         By default, it is 0.5 second.
 |       - ignored_exceptions - iterable structure of exception classes ignored
during calls.
 |         By default, it contains NoSuchElementException only.
 |
 |      Example:
 |       from selenium.webdriver.support.ui import WebDriverWait
 |
 |       element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_i
d("someId"))
 |
 |       is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleExcepti
on)).\
 |
 |                   until_not(lambda x: x.find_element_by_id("someId").is_displ
ayed())

Créez un objet instance de la classe WebDriverWait : WebDriverWait(driver, timeout, poll_ Frequency=0.5, ignoré_exceptions=None)

Il y a principalement 4 paramètres :

pilote : pilote de navigateur

timeout : temps d'attente

poll_ Frequency : intervalle de détection, par défaut 0,5 s

ignoré_exceptions : informations sur l'exception après l'expiration du délai, NoSuchElementException est levée par défaut

⑤La classe WebDriverWait est utilisée pour afficher l'attente  :

à partir de selenium.webdriver.support.wait importer WebDriverWait

Exemple de code 1 :

#encoding=utf-8
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

#获取单个页面元素对象,显示等待
#locateType查找的方法类型
#locatorExpression查找的表达式
def getElement(driver,locateType,locatorExpression):
    try:
        element=WebDriverWait(driver,5).until(lambda x: x.find_element(by=locateType, value=locatorExpression))
    except Exception, e:
        raise e

Exemple de code 2 :

# coding = utf-8
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait

# 驱动文件路径
driverfile_path = r'D:\coship\Test_Framework\drivers\chromedriver.exe'
# 启动浏览器
driver = webdriver.Chrome(executable_path=driverfile_path)
# 打开百度首页
driver.get(r'https://www.baidu.com/')
driver.find_element_by_css_selector("#kw").send_keys("selenium")
driver.find_element_by_css_selector("#su").click()
# 超时时间为30秒，每0.2秒检查1次，直到class="tt"的元素出现
text = WebDriverWait(driver, 30, 0.2).until(lambda x:x.find_element_by_css_selector(".tt")).text
print(text)
# 退出
driver.quit()

Exemple de code 3 :

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

driver = webdriver.Firefox()
driver.get('http://www.baidu.com')

element = WebDriverWait(driver, 5, 0.5).until(EC.presence_of_element_located((By.ID, "kw")))
element.send_keys('selenium')

Dans cet exemple, renommez Expected_conditions en EC via le mot-clé as et appelez la méthode présence_of_element_located() pour déterminer si l'élément existe.

Méthode de jugement des conditions attendues fournie par la classe Expected_conditions

méthode	illustrer
titre_is	Détermine si le titre de la page actuelle est complètement égal à (==) la chaîne attendue et renvoie une valeur booléenne
titre_contient	Détermine si le titre de la page actuelle contient la chaîne attendue et renvoie une valeur booléenne
présence_of_element_located	Déterminer si un élément a été ajouté à l'arborescence dom ne signifie pas que l'élément doit être visible.
visibilité_of_element_located	Détermine si un élément est visible. Visible signifie que l'élément n'est pas masqué et que la largeur et la hauteur de l'élément ne sont pas égales à 0.
visibilité_de	Elle fait la même chose que la méthode ci-dessus, sauf que la méthode ci-dessus doit transmettre le localisateur. Cette méthode peut transmettre directement l'élément localisé.
présence_of_all_elements_located	Déterminez si au moins 1 élément existe dans l’arborescence dom. Par exemple, s'il y a n éléments sur la page avec des classes toutes « colonne-md-3 », alors tant qu'il existe 1 élément, cette méthode retournera True.
text_to_be_present_in_element	Déterminer si le texte d'un élément contient la chaîne attendue
text_to_be_present_in_element_value	Déterminer si l'attribut value dans un élément contient la chaîne attendue
frame_to_be_available_and_switch_to_it	Déterminez si la trame peut être activée. Si tel est le cas, renvoyez True et activez, sinon renvoyez False.
invisibilité_of_element_located	Déterminer si un élément n'existe pas dans l'arborescence DOM ou est invisible
element_to_be_clickable	Détermine si un élément est visible et activé. Dans ce cas, il est appelé cliquable.
obsolescence_de	Attendez qu'un élément soit supprimé de l'arborescence DOM. Notez que cette méthode renvoie également True ou False.
element_to_be_selected	Déterminer si un élément est sélectionné, généralement utilisé dans les listes déroulantes
element_selection_state_to_be	Déterminer si l'état sélectionné d'un élément est comme prévu
element_located_selection_state_to_be	La fonction est la même que la méthode ci-dessus, sauf que la méthode ci-dessus passe dans l'élément localisé et que cette méthode passe dans le localisateur.
alert_is_present	Déterminer si une alerte existe sur la page

Il existe deux scénarios d'utilisation pour les conditions attendues :

• Utiliser directement dans les assertions
• Utilisé conjointement avec WebDriverWait() pour attendre dynamiquement que des éléments de la page apparaissent ou disparaissent

Exemple:

#encoding:utf-8
# example of how to use https://github.com/SeleniumHQ/selenium/blob/master/py/selenium/webdriver/support/expected_conditions.py

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

import unittest

# dr = webdriver.PhantomJS('phantomjs')
dr = webdriver.Firefox()
# dr = webdriver.Chrome()
url = 'http://www.baidu.com'
search_text_field_id = 'kw'
dr.get(url)

class ECExample(unittest.TestCase):

  def test_title_is(self):
    ''' 判断title是否符合预期 '''
    title_is_baidu = EC.title_is(u'百度一下，你就知道')
    self.assertTrue(title_is_baidu(dr))

  def test_titile_contains(self):
    ''' 判断title是否包含预期字符 '''
    title_should_contains_baidu = EC.title_contains(u'百度')
    self.assertTrue(title_should_contains_baidu(dr))

  def test_presence_of_element_located(self):
    ''' 判断element是否出现在dom树 '''
    locator = (By.ID, search_text_field_id)
    search_text_field_should_present = EC.visibility_of_element_located(locator)

    ''' 动态等待10s，如果10s内element加载完成则继续执行下面的代码，否则抛出异常 '''
    WebDriverWait(dr, 10).until(EC.presence_of_element_located(locator))
    WebDriverWait(dr, 10).until(EC.visibility_of_element_located(locator))

    self.assertTrue(search_text_field_should_present(dr))

  def test_visibility_of(self):
    search_text_field = dr.find_element_by_id(search_text_field_id)
    search_text_field_should_visible = EC.visibility_of(search_text_field)
    self.assertTrue(search_text_field_should_visible('yes'))

  def test_text_to_be_present_in_element(self):
    text_should_present = EC.text_to_be_present_in_element((By.NAME, 'tj_trhao123'), 'hao123')
    self.assertTrue(text_should_present(dr))


  @classmethod
  def tearDownClass(kls):
    print 'after all test'
    dr.quit()
    print 'quit dr'

if __name__ == '__main__':
  unittest.main()

Prenons title_is comme exemple :

class title_is(object):
    """An expectation for checking the title of a page.
    title is the expected title, which must be an exact match
    returns True if the title matches, false otherwise."""
    def __init__(self, title):
        self.title = title

    def __call__(self, driver):
        return self.title == driver.title

Vous pouvez voir que title_is est en fait une classe et que sa méthode __call__ est définie pour renvoyer une valeur booléenne. L’usage général est donc le suivant :

# 实例化
the_instance = title_is('expected')
# 直接在实例上调用__call__
the_instance(dr) #return True or False

Explication détaillée de webDriverWait()

WebDriverWait(self,driver, timeout, poll_fréquence=POLL_FREQUENCY, ignoré_exceptions=None).until(self, méthode, message=)

ou:

WebDriverWait(self, driver, timeout, poll_fréquence=POLL_FREQUENCY, ignoré_exceptions=None).until_not(self,method, message=)

① self : la fonction elle-même ne nécessite aucune saisie lorsqu'elle est réellement utilisée.

② pilote : pilote webdriver, tel que (IE, FireFox, chrome, safari, etc.).

③ timeout : délai d'expiration, l'unité par défaut est poll_fréquence, l'intervalle de temps de sommeil (taille du pas), la valeur par défaut est 0,5 seconde , qui est la fréquence de détection de l'existence de l'élément.

④ ignoré_exceptions : informations d'exception après l'expiration du délai. Par défaut, NoSuchElementException est levée. Vous pouvez définir les informations d'exception à ignorer.

⑤ WebDriverWait est généralement utilisé en conjonction avec Until ou Until_not.

⑥ jusqu'à(method, message=") : Appelez le pilote fourni par cette méthode en tant que paramètre jusqu'à ce que la valeur de retour ne soit pas False.

⑦ jusqu'à ce que_not(method, message=") : appelle le pilote fourni par cette méthode en tant que paramètre jusqu'à ce que la valeur de retour soit False.

Application pratique

Dans les tests automatisés, il est souvent nécessaire d'attendre un certain élément sur la page pour passer à l'étape suivante, ou pour afficher le chargement dans la liste, et de passer à l'étape suivante jusqu'à ce que le chargement soit terminé, mais le temps est incertain. , comme le montre la figure suivante :

le code s'affiche comme ci-dessous :

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



# 一直等待某元素可见，默认超时10秒
def is_visible(locator, timeout=10):
    try:
        ui.WebDriverWait(driver, timeout).until(EC.visibility_of_element_located((By.XPATH, locator)))
        return True
    except TimeoutException:
        return False

# 一直等待某个元素消失，默认超时10秒
def is_not_visible(locator, timeout=10):
    try:
        ui.WebDriverWait(driver, timeout).until_not(EC.visibility_of_element_located((By.XPATH, locator)))
        return True
    except TimeoutException:
        return False

# 调用
is_not_visible('//input[@input="search-error"]') 

Enfin, je voudrais remercier tous ceux qui ont lu attentivement mon article. En regardant l'augmentation du nombre de fans et de l'attention, il y a toujours une certaine courtoisie. Même si ce n'est pas une chose très précieuse, si vous pouvez l'utiliser, vous pouvez le prendre directement !

Applet d'entretien de test logiciel

Une banque de questions de tests logiciels qui a été utilisée par des millions de personnes ! ! ! Qui est qui sait ! ! ! Le mini-programme de test d'entretien le plus complet sur Internet, vous pouvez utiliser votre téléphone portable pour répondre aux questions, prendre le métro, le bus et le rouler !

Couvre les sections de questions d'entretien suivantes :

1. Théorie de base des tests logiciels, 2. Web, applications, tests de fonctions d'interface, 3. réseau, 4. base de données, 5. Linux

6. Web, application, automatisation de l'interface, 7. tests de performances, 8. bases de la programmation, 9. questions d'entretien RH, 10. questions de test ouvertes, 11. tests de sécurité, 12. bases de l'informatique

Comment obtenir des informations :