Selenium2+python自动化42-判断元素(expected_conditions)【转载】

前言

经常有小伙伴问,如何判断一个元素是否存在,如何判断alert弹窗出来了,如何判断动态的元素等等一系列的判断,在selenium的expected_conditions模块收集了一系列的场景判断方法,这些方法是逢面试必考的!!!

expected_conditions一般也简称EC,本篇先介绍下有哪些功能,后续更新中会单个去介绍。

一、功能介绍和翻译

title_is: 判断当前页面的title是否完全等于(==)预期字符串,返回布尔值

title_contains : 判断当前页面的title是否包含预期字符串,返回布尔值

presence_of_element_located : 判断某个元素是否被加到了dom树里,并不代表该元素一定可见

visibility_of_element_located : 判断某个元素是否可见. 可见代表元素非隐藏,并且元素的宽和高都不等于0

visibility_of : 跟上面的方法做一样的事情,只是上面的方法要传入locator,这个方法直接传定位到的element就好了

presence_of_all_elements_located : 判断是否至少有1个元素存在于dom树中。举个例子,如果页面上有n个元素的class都是‘column-md-3‘,那么只要有1个元素存在,这个方法就返回True

text_to_be_present_in_element : 判断某个元素中的text是否 包含 了预期的字符串

text_to_be_present_in_element_value : 判断某个元素中的value属性是否 包含 了预期的字符串

frame_to_be_available_and_switch_to_it : 判断该frame是否可以switch进去,如果可以的话,返回True并且switch进去,否则返回False

invisibility_of_element_located : 判断某个元素中是否不存在于dom树或不可见

element_to_be_clickable : 判断某个元素中是否可见并且是enable的,这样的话才叫clickable

staleness_of : 等某个元素从dom树中移除,注意,这个方法也是返回True或False

element_to_be_selected : 判断某个元素是否被选中了,一般用在下拉列表

element_selection_state_to_be : 判断某个元素的选中状态是否符合预期

element_located_selection_state_to_be : 跟上面的方法作用一样,只是上面的方法传入定位到的element,而这个方法传入locator

alert_is_present : 判断页面上是否存在alert

二、查看源码和注释

1.打开python里这个目录l可以找到:Lib\site-packages\selenium\webdriver\support\expected_conditions.py

from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoSuchFrameException
from selenium.common.exceptions import StaleElementReferenceException
from selenium.common.exceptions import WebDriverException
from selenium.common.exceptions import NoAlertPresentException

"""
 * Canned "Expected Conditions" which are generally useful within webdriver
 * tests.
"""

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

class title_contains(object):
    """ An expectation for checking that the title contains a case-sensitive
    substring. title is the fragment of title expected
    returns True when the title matches, False otherwise
    """
    def __init__(self, title):
        self.title = title

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

class presence_of_element_located(object):
    """ An expectation for checking that an element is present on the DOM
    of a page. This does not necessarily mean that the element is visible.
    locator - used to find the element
    returns the WebElement once it is located
    """
    def __init__(self, locator):
        self.locator = locator

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

class visibility_of_element_located(object):
    """ An expectation for checking that an element is present on the DOM of a
    page and visible. Visibility means that the element is not only displayed
    but also has a height and width that is greater than 0.
    locator - used to find the element
    returns the WebElement once it is located and visible
    """
    def __init__(self, locator):
        self.locator = locator

def __call__(self, driver):
        try:
            return _element_if_visible(_find_element(driver, self.locator))
        except StaleElementReferenceException:
            return False

class visibility_of(object):
    """ An expectation for checking that an element, known to be present on the
    DOM of a page, is visible. Visibility means that the element is not only
    displayed but also has a height and width that is greater than 0.
    element is the WebElement
    returns the (same) WebElement once it is visible
    """
    def __init__(self, element):
        self.element = element

def __call__(self, ignored):
        return _element_if_visible(self.element)

def _element_if_visible(element, visibility=True):
    return element if element.is_displayed() == visibility else False

class presence_of_all_elements_located(object):
    """ An expectation for checking that there is at least one element present
    on a web page.
    locator is used to find the element
    returns the list of WebElements once they are located
    """
    def __init__(self, locator):
        self.locator = locator

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

class visibility_of_any_elements_located(object):
    """ An expectation for checking that there is at least one element visible
    on a web page.
    locator is used to find the element
    returns the list of WebElements once they are located
    """
    def __init__(self, locator):
        self.locator = locator

def __call__(self, driver):
        return [element for element in _find_elements(driver, self.locator) if _element_if_visible(element)]

class text_to_be_present_in_element(object):
    """ An expectation for checking if the given text is present in the
    specified element.
    locator, text
    """
    def __init__(self, locator, text_):
        self.locator = locator
        self.text = text_

def __call__(self, driver):
        try:
            element_text = _find_element(driver, self.locator).text
            return self.text in element_text
        except StaleElementReferenceException:
            return False

class text_to_be_present_in_element_value(object):
    """
    An expectation for checking if the given text is present in the element‘s
    locator, text
    """
    def __init__(self, locator, text_):
        self.locator = locator
        self.text = text_

def __call__(self, driver):
        try:
            element_text = _find_element(driver,
                                         self.locator).get_attribute("value")
            if element_text:
                return self.text in element_text
            else:
                return False
        except StaleElementReferenceException:
                return False

class frame_to_be_available_and_switch_to_it(object):
    """ An expectation for checking whether the given frame is available to
    switch to.  If the frame is available it switches the given driver to the
    specified frame.
    """
    def __init__(self, locator):
        self.frame_locator = locator

def __call__(self, driver):
        try:
            if isinstance(self.frame_locator, tuple):
                driver.switch_to.frame(_find_element(driver,
                                                     self.frame_locator))
            else:
                driver.switch_to.frame(self.frame_locator)
            return True
        except NoSuchFrameException:
            return False

class invisibility_of_element_located(object):
    """ An Expectation for checking that an element is either invisible or not
    present on the DOM.

locator used to find the element
    """
    def __init__(self, locator):
        self.locator = locator

def __call__(self, driver):
        try:
            return _element_if_visible(_find_element(driver, self.locator), False)
        except (NoSuchElementException, StaleElementReferenceException):
            # In the case of NoSuchElement, returns true because the element is
            # not present in DOM. The try block checks if the element is present
            # but is invisible.
            # In the case of StaleElementReference, returns true because stale
            # element reference implies that element is no longer visible.
            return True

class element_to_be_clickable(object):
    """ An Expectation for checking an element is visible and enabled such that
    you can click it."""
    def __init__(self, locator):
        self.locator = locator

def __call__(self, driver):
        element = visibility_of_element_located(self.locator)(driver)
        if element and element.is_enabled():
            return element
        else:
            return False

class staleness_of(object):
    """ Wait until an element is no longer attached to the DOM.
    element is the element to wait for.
    returns False if the element is still attached to the DOM, true otherwise.
    """
    def __init__(self, element):
        self.element = element

def __call__(self, ignored):
        try:
            # Calling any method forces a staleness check
            self.element.is_enabled()
            return False
        except StaleElementReferenceException:
            return True

class element_to_be_selected(object):
    """ An expectation for checking the selection is selected.
    element is WebElement object
    """
    def __init__(self, element):
        self.element = element

def __call__(self, ignored):
        return self.element.is_selected()

class element_located_to_be_selected(object):
    """An expectation for the element to be located is selected.
    locator is a tuple of (by, path)"""
    def __init__(self, locator):
        self.locator = locator

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

class element_selection_state_to_be(object):
    """ An expectation for checking if the given element is selected.
    element is WebElement object
    is_selected is a Boolean."
    """
    def __init__(self, element, is_selected):
        self.element = element
        self.is_selected = is_selected

def __call__(self, ignored):
        return self.element.is_selected() == self.is_selected

class element_located_selection_state_to_be(object):
    """ An expectation to locate an element and check if the selection state
    specified is in that state.
    locator is a tuple of (by, path)
    is_selected is a boolean
    """
    def __init__(self, locator, is_selected):
        self.locator = locator
        self.is_selected = is_selected

def __call__(self, driver):
        try:
            element = _find_element(driver, self.locator)
            return element.is_selected() == self.is_selected
        except StaleElementReferenceException:
            return False

class alert_is_present(object):
    """ Expect an alert to be present."""
    def __init__(self):
        pass

def __call__(self, driver):
        try:
            alert = driver.switch_to.alert
            alert.text
            return alert
        except NoAlertPresentException:
            return False

def _find_element(driver, by):
    """Looks up an element. Logs and re-raises ``WebDriverException``
    if thrown."""
    try:
        return driver.find_element(*by)
    except NoSuchElementException as e:
        raise e
    except WebDriverException as e:
        raise e

def _find_elements(driver, by):
    try:
        return driver.find_elements(*by)
    except WebDriverException as e:
        raise e

本篇的判断方法和场景很多,先贴出来,后面慢慢更新,详细讲解每个的功能的场景和用法。

这些方法是写好自动化脚本,提升性能的必经之路,想做好自动化,就得熟练掌握。

时间: 2024-10-01 04:39:15

Selenium2+python自动化42-判断元素(expected_conditions)【转载】的相关文章

Selenium2+python自动化52-unittest执行顺序【转载】

本篇转自博客:上海-悠悠 原文地址:http://www.cnblogs.com/yoyoketang/tag/unittest/ 前言 很多初学者在使用unittest框架时候,不清楚用例的执行顺序到底是怎样的.对测试类里面的类和方法分不清楚,不知道什么时候执行,什么时候不执行. 本篇通过最简单案例详细讲解unittest执行顺序. 一.案例分析 1.先定义一个测试类,里面写几个简单的case # coding:utf-8import unittestimport timeclass Test

Selenium2+python自动化20-Excel数据参数化【转载】

前言 问: Python 获取到Excel一列值后怎么用selenium录制的脚本中参数化,比如对登录用户名和密码如何做参数化? 答:可以使用xlrd读取Excel的内容进行参数化.当然为了便于各位小伙伴们详细的了解,小编一一介绍具体的方法. 一.编写登录用例: Step1:访问http://www.effevo.com (打个广告effevo是搜狗自研发的项目管理系统,完全免费,非常好用)Step2:点击页面右上角的登录Step3:输入用户名和密码后登录Step4:检查右上角的头像是否存在实现

Selenium2+python自动化36-判断元素存在

前言 最近有很多小伙伴在问如何判断一个元素是否存在,这个方法在selenium里面是没有的,需要自己写咯. 元素不存在的话,操作元素会报错,或者元素有多个,不唯一的时候也会报错.本篇介绍两种判断元素存在的方法. 一.find_elements方法判断 1.find_elements方法是查找页面上所有相同属性的方法,这个方法其实非常好用,能熟练掌握技巧的不多,小编这次就发挥它的功效 2.由于元素定位的方法很多,所以判断的时候定位方法不统一也比较麻烦,这里我选择css定位(有喜欢xpath的同学可

Selenium2+python自动化42-判断元素(expected_conditions)

前言 经常有小伙伴问,如何判断一个元素是否存在,如何判断alert弹窗出来了,如何判断动态的元素等等一系列的判断,在selenium的expected_conditions模块收集了一系列的场景判断方法,这些方法是逢面试必考的!!! expected_conditions一般也简称EC,本篇先介绍下有哪些功能,后续更新中会单个去介绍. 一.功能介绍和翻译 title_is: 判断当前页面的title是否完全等于(==)预期字符串,返回布尔值 title_contains : 判断当前页面的tit

Selenium2+python自动化12-操作元素(键盘和鼠标事件)【转载】

前言 在前面的几篇中重点介绍了一些元素的到位方法,到位到元素后,接下来就是需要操作元素了.本篇总结了web页面常用的一些操作元素方法,可以统称为行为事件 有些web界面的选项菜单需要鼠标悬停在某个元素上才能显示出来(如百度页面的设置按钮). 一.简单操作 1.点击(鼠标左键)页面按钮:click() 2.请空输入框:clear() 3.输入字符串:send_keys() 4.打开测试部落论坛后,点击放大镜搜索图标,一般为了保证输入的正确性,可以先清空下输入框,然后输入搜索关键字 二.submit

Selenium2+python自动化6-八种元素元素定位(Firebug和firepath)

前言 自动化只要掌握四步操作:获取元素,操作元素,获取返回结果,断言(返回结果与期望结果是否一致),最后自动出测试报告.本篇主要讲如何用firefox辅助工具进行元素定位. 元素定位在这四个环节中是至关重要的,如果说按学习精力分配的话,元素定位占70%:操作元素10%,获取返回结果10%:断言10%.如果一个页面上的元素不能被定位到,那后面的操作就无法继续了.接下来就来讲webdriver提供的八种基本元素定位方法. 一.环境准备: 1.浏览器选择:Firefox 2.安装插件:Firebug和

Selenium2+python自动化21-TXT数据参数化【转载】

前言      在17篇我们讲了excel数据的参数化,有人问了txt数据的参数化该怎么办呢,下面小编为你带你txt数据参数化的讲解 一.以百度搜索为例,自动搜索五次不同的关键字.输入的数据不同从而引起输出结果的变化. 测试脚本: #coding=utf-8from selenium import webdriverimport unittest, time, osclass Login(unittest.TestCase): def test_login(self): source = ope

Selenium2+python自动化02-八种元素定位(Firebug和Firepath)

前言    自动化只要掌握四步操作:获取元素,操作元素,获取返回结果,断言(返回结果与期望结果是否一致),最后自动出测试报告.本篇主要讲如何用firefox辅助工具进行元素定位.元素定位在这四个环节中是至关重要的,如果说按学习精力分配的话,元素定位占70%:操作元素10%,获取返回结果10%:断言10%.如果一个页面上的元素不能被定位到,那后面的操作就无法继续了.接下来就来讲webdriver提供的八种基本元素定位方法. 一.环境准备: 1.浏览器选择:Firefox 2.安装插件:Firebu

Selenium2+python自动化12-操作元素(键盘和鼠标事件)

前言 在前面的几篇中重点介绍了一些元素的到位方法,到位到元素后,接下来就是需要操作元素了.本篇总结了web页面常用的一些操作元素方法,可以统称为行为事件 有些web界面的选项菜单需要鼠标悬停在某个元素上才能显示出来(如百度页面的设置按钮). 一.简单操作 1.点击(鼠标左键)页面按钮:click() 2.请空输入框:clear() 3.输入字符串:send_keys() 4.打开测试部落论坛后,点击放大镜搜索图标,一般为了保证输入的正确性,可以先清空下输入框,然后输入搜索关键字 二.submit