Affichage en attente de test automatisé de sélénium

Table des matières

condition d'attente

Le principe de réalisation de la classe conditionnelle

Comment WebDriverWait juge-t-il les conditions

Quelles sont les conditions dans le sélénium

Ensuite c'est personnalisé

 Résumer:

---

Lors des tests d'automatisation de l'interface utilisateur, afin de maintenir la stabilité du cas d'utilisation, nous devons souvent définir l'attente d'affichage. L'attente d'affichage signifie que nous devons attendre qu'un élément apparaisse ou que certaines conditions de l'élément apparaissent, telles que cliquable, visible, etc. , si aucun n'est trouvé dans le délai spécifié, il sera lancé Exception.

Ce qui précède est un cas de test que j'ai seleniumécrit, qui montre seleniumcomment utiliser l'attente d'affichage, qui utilisera expected_conditionsdes modules et WebDriverWaitdes classes.Notez qu'il expected_conditionss'agit du nom de fichier d'un fichier py, qui est un nom de module.Il existe de nombreuses conditions sous ce module classe, et ce que nous utilisons dans notre cas d'utilisation title_isest une classe conditionnelle.

WebDriverWaitC'est une classe, et la fonction de cette classe est de vérifier en permanence si la condition est remplie selon certaines conditions. WebDriverWaitLa classe n'a que deux méthodes, l'une untiljusqu'à ce qu'une certaine condition soit remplie et l'autre until_notjusqu'à ce qu'une certaine condition ne soit pas remplie.

class WebDriverWait(object):
    def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, ignored_exceptions=None):

WebDriverWaitIl existe quatre paramètres : driverconducteur,  timeoutdélai d'expiration  poll_frequency=POLL_FREQUENCYet temps de formation, c'est-à-dire l'intervalle de temps permettant de déterminer si les conditions sont remplies. La valeur par défaut est de 0,5 seconde.  ignored_exceptions=NoneLes exceptions qui doivent être ignorées pendant le processus d'attente sont une collection itérable de exceptions. Par exemple, nous pouvons définir une liste, qui est [NoSuchElementException,NoSuchAttributeException,InvalidElementStateException....], par défaut, un tuple, qui ne contient qu'un seul NoSuchElementException, car ce n'est que lorsque l'élément apparaît que nous pouvons juger si la condition est satisfaite. Dans le processus de formation continue, il sera se produira définitivement NoSuchElementException. À ce stade, il doit être ignoré. Supprimez cette exception, sinon le programme sera interrompu.

Parmi eux driver, et timeoutsont les paramètres de position de Bi Chuan, et les deux autres sont des paramètres de mots clés qui sont sélectionnés pour être transmis. S'ils ne sont pas transmis, ils auront des valeurs par défaut spécifiées.

Entrons dans notre sujet aujourd'hui, la discussion des conditions d'attente en sélénium

condition d'attente

Le principe de réalisation de la classe conditionnelle

Dans selenium.webdriver.support.expected_conditionsce module, toutes les conditions d'attente sont stockées et la structure de chaque classe de condition est la même qu'une __init__méthode de construction et une __call__méthode.

En python, si vous souhaitez utiliser un type d'objet en tant que fonction, vous pouvez implémenter __call__des méthodes pour cette classe, comme suit :

class TestCase:
    def __init__(self):
        self.driver = webdriver.Chrome(executable_path="./driver/chromedriver")
        self.driver.get('http://www.baidu.com')
        # sleep(2)

    def __call__(self):
        print(self.driver.title)

if __name__ == '__main__':
    case = TestCase()
    case()

case()L'appel de l'objet exécutera __call__la logique dans la méthode pour imprimer le titre de la page en cours. Nous prenons une classe d'implémentation sélénium :

class presence_of_element_located(object):

    def __init__(self, locator):
        self.locator = locator

    def __call__(self, driver):
        return _find_element(driver, self.locator)

La signification de cette classe de condition est de juger si un élément a été rendu sur la page. Lors de l'utilisation de cette condition, elle doit d'abord être instanciée, et le positionnement de l'élément est transmis. Ensuite, lorsque le jugement est rendu, le L'objet d'instance doit être appelé et transmis. driverPour Lorsque l'objet d'instance appelle, il exécutera __call__la logique de jugement conditionnel dans la méthode.

WebDriverWaitComment juger de l'état

Retournez au début de l'article et regardez le code que nous utilisons pour afficher l'attente :

wait = WebDriverWait(self.driver, 2)
wait.until(EC.title_is('百度一下，你就知道'))

Commencez par instancier un WebDriverWaitobjet, puis appelez untilla méthode et passez un objet d'instance conditionnel, et untilla méthode apprendra en permanence si la condition est remplie.

def until(self, method, message=''):
    screen = None
    stacktrace = None

    end_time = time.time() + self._timeout
    while True:
        try:
            value = method(self._driver)
            if value:
                return value
        except self._ignored_exceptions as exc:
            screen = getattr(exc, 'screen', None)
            stacktrace = getattr(exc, 'stacktrace', None)
        time.sleep(self._poll)
        if time.time() > end_time:
            break
    raise TimeoutException(message, screen, stacktrace)

methodCe paramètre est l'objet instance de la condition que nous avons passée, value = method(self._driver)ici pour appeler l'objet, c'est-à-dire pour exécuter __call__la logique dans la méthode.

Quelles sont les conditions dans le sélénium

• title_is pour déterminer si le titre apparaît
• title_contains détermine si le titre de la page de titre contient certains caractères
• presence_of_element_located détermine si un élément est chargé dans l'arbre dom, mais cela ne signifie pas que l'élément est visible
• url_contains détermine si l'url actuelle contient une certaine url
• url_matches pour déterminer si l'url actuelle est conforme à un certain format
• url_to_be Détermine si l'url actuelle apparaît
• url_changes Détermine si l'url actuelle a changé
• visibilité_of_element_located détermine si un élément a été ajouté à l'arborescence dom, et la largeur et la hauteur sont supérieures à 0
• visibilité_of détermine si un élément est visible
• presence_of_all_elements_located détermine qu'au moins un élément existe dans l'arbre dom et renvoie tous les éléments localisés
• visibilité_of_any_elements_located détermine qu'au moins un élément est visible sur la page
• visibilité_of_all_elements_located détermine si tous les éléments sont visibles sur la page
• text_to_be_present_in_element détermine si la chaîne attendue est contenue dans l'élément spécifié
• text_to_be_present_in_element_value Détermine si la valeur d'attribut d'élément spécifiée contient la chaîne attendue
• frame_to_be_available_and_switch_to_it détermine si l'iframe peut être activé
• invisibility_of_element_located détermine si un élément est invisible dans le dom
• element_to_be_clickable détermine si un élément est visible et activé, c'est-à-dire s'il peut être cliqué
• staleness_of attend qu'un élément soit supprimé du dom
• element_to_be_selected détermine si un élément est sélectionné, généralement utilisé dans les listes déroulantes
• element_located_to_be_selected a la même signification que ci-dessus, sauf que l'objet élément est passé lorsque ce qui précède est instancié, et c'est l'emplacement
• element_selection_state_to_be détermine si l'état sélectionné d'un élément répond aux attentes
• element_located_selection_state_to_be est le même que ci-dessus, mais la valeur est différente
• number_of_windows_to_be détermine si le nombre actuel de fenêtres est égal au nombre attendu
• new_window_is_opened pour déterminer s'il y a une augmentation de la fenêtre
• alert_is_present Juge s'il y a une fenêtre pop-up sur la page

Ce qui précède sont toutes les conditions prises en charge par le sélénium.

Ensuite c'est personnalisé

Après avoir dit tant de conditions, en fait, nous pouvons également implémenter une classe de conditions par nous-mêmes,

class page_is_load:
    
    def __init__(self, expected_title, expected_url):
        self.expected_title = expected_title
        self.expected_url = expected_url
    
    def __call__(self, driver):
        is_title_correct = driver.title == self.expected_title
        is_url_correct = driver.current_url == self.expected_url
        return is_title_correct and is_url_correct

Ce qui précède est une classe conditionnelle implémentée par moi-même, qui juge si la page est correctement chargée en fonction de l'URL et du titre de la page.

class TestCase:
    def __init__(self):
        self.driver = webdriver.Chrome(executable_path="./driver/chromedriver")
        self.driver.get('http://www.baidu.com/')
        # sleep(2)

    def __call__(self):
        print(self.driver.title)

    def test_wait(self):
        wait = WebDriverWait(self.driver, 2)
        wait.until(page_is_load("百度一下，你就知道", "http://www.baidu.com/"))