def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, 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 \n
element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \n
is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\ \n
until_not(lambda x: x.find_element_by_id("someId").is_displayed())
"""

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait
driver = webdriver.Firefox()
driver.get("http://www.baidu.com")
# 等待时长10秒，默认0.5秒询问一次
WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("kw")).send_keys("yoyo")
# 判断id为kw元素是否消失
is_disappeared = WebDriverWait(driver, 10, 1).\
until_not(lambda x: x.find_element_by_id("kw").is_displayed())
print is_disappeared

# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
import time
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import TimeoutException
POLL_FREQUENCY = 0.5  # How long to sleep inbetween calls to the method
IGNORED_EXCEPTIONS = (NoSuchElementException,)  # exceptions ignored during calls to the method
class WebDriverWait(object):
def __init__(self, driver, timeout, poll_frequency=POLL_FREQUENCY, 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 \n
element = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_id("someId")) \n
is_disappeared = WebDriverWait(driver, 30, 1, (ElementNotVisibleException)).\ \n
until_not(lambda x: x.find_element_by_id("someId").is_displayed())
"""
self._driver = driver
self._timeout = timeout
self._poll = poll_frequency
# avoid the divide by zero
if self._poll == 0:
self._poll = POLL_FREQUENCY
exceptions = list(IGNORED_EXCEPTIONS)
if ignored_exceptions is not None:
try:
exceptions.extend(iter(ignored_exceptions))
except TypeError:  # ignored_exceptions is not iterable
                exceptions.append(ignored_exceptions)
self._ignored_exceptions = tuple(exceptions)
def __repr__(self):
return '<{0.__module__}.{0.__name__} (session="{1}")>'.format(
type(self), self._driver.session_id)
def until(self, method, message=''):
"""Calls the method provided with the driver as an argument until the \
return value is not False."""
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)
def until_not(self, method, message=''):
"""Calls the method provided with the driver as an argument until the \
return value is False."""
end_time = time.time() + self._timeout
while True:
try:
value = method(self._driver)
if not value:
return value
except self._ignored_exceptions:
return True
time.sleep(self._poll)
if time.time() > end_time:
break
raise TimeoutException(message)

"""
The By implementation.
"""
class By(object):
"""
Set of supported locator strategies.
"""
ID = "id"
XPATH = "xpath"
LINK_TEXT = "link text"
PARTIAL_LINK_TEXT = "partial link text"
NAME = "name"
TAG_NAME = "tag name"
CLASS_NAME = "class name"
CSS_SELECTOR = "css selector"

by_id= "id"
by_xpath = "xpath"
by_link_text = "link text"
by_partial_text = "partial link text"
by_name = "name"
by_tag_name = "tag name"
by_class_name = "class name"
by_css_selector = "css selector"

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.get("https://www.baidu.com/")
driver.find_element("id", "kw").send_keys("yoyoketang")
driver.find_element('css selector', "#su").click()
# 其它定位参考 交流QQ群：232607095
# t1 = driver.find_element("link text", "糯米").text
# print t1
# t2 = driver.find_element("name", "tj_trnews").text
# print t2
# t3 = driver.find_element("class name", "bri").text
# print t3

# coding:utf-8
from selenium import webdriver
import unittest
import time
class Bolg(unittest.TestCase):
u'''登录博客'''
def setUp(self):
self.driver = webdriver.Firefox()
url = "https://passport.cnblogs.com/user/signin"
self.driver.get(url)
self.driver.implicitly_wait(30)
def login(self, username, psw):
u'''这里写了一个登录的方法,账号和密码参数化'''
self.driver.find_element_by_id("input1").send_keys(username)
self.driver.find_element_by_id("input2").send_keys(psw)
self.driver.find_element_by_id("signin").click()
time.sleep(3)
def is_login_sucess(self):
u'''判断是否获取到登录账户名称'''
try:
text = self.driver.find_element_by_id("lnk_current_user").text
print text
return True
except:
return False
def test_01(self):
u'''登录案例参考:账号，密码自己设置'''
self.login(u"上海-悠悠", u"xxxx")  # 调用登录方法
# 判断结果
result = self.is_login_sucess()
self.assertTrue(result)
def test_02(self):
u'''登录案例参考:账号，密码自己设置'''
self.login(u"上海-悠悠", u"xxxx")  # 调用登录方法
# 判断结果   # 交流QQ群：232607095
result = self.is_login_sucess()
self.assertTrue(result)
# def test_01(self):
#     u'''登录案例参考:账号，密码自己设置'''
#     self.login(u"上海-悠悠", u"xxxx")  # 调用登录方法
#     # 获取登录后的账号名称
#     text = self.driver.find_element_by_id("lnk_current_user").text
#     print text
#     # 断言实际结果与期望结果一致
#     self.assertEqual(text, u"上海-悠悠")
#
    # def test_02(self):
#     u'''登录案例参考:账号，密码自己设置'''
#     self.login(u"上海-悠悠", u"oooo")  # 调用登录方法
#     # 获取登录后的账号名称
#     text = self.driver.find_element_by_id("lnk_current_user").text
#     print text            # 断言实际结果与期望结果一致
#     self.assertEqual(text, u"上海-悠悠")

def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()

data = xlrd.open_workbook('test.xlsx')
# table = data.sheets()[0]           #  通过索引顺序获取
# table = data.sheet_by_index(0)     #  通过索引顺序获取
table = data.sheet_by_name(u'Sheet1')  # 通过名称获取
nrows = table.nrows  # 获取总行数
ncols = table.ncols  # 获取总列数
#　获取一行或一列的值，参数是第几行
print table.row_values(0)  # 获取第一行值
print table.col_values(0)  # 获取第一列值

# coding:utf-8
import xlrd
class ExcelUtil():
def __init__(self, excelPath, sheetName):
self.data = xlrd.open_workbook(excelPath)
self.table = self.data.sheet_by_name(sheetName)
# 获取第一行作为key值
self.keys = self.table.row_values(0)
# 获取总行数
self.rowNum = self.table.nrows
# 获取总列数
self.colNum = self.table.ncols
def dict_data(self):
if self.rowNum <= 1:
print("总行数小于1")
else:
r = []
j=1
for i in range(self.rowNum-1):
s = {}
# 从第二行取对应values值
values = self.table.row_values(j)
for x in range(self.colNum):
s[self.keys[x]] = values[x]
r.append(s)
j+=1
return r
if __name__ == "__main__":
# 注意：此代码if以上的勿乱改，调用此方法只需修改两个参数，一个是excelPath存放xlsx的路径，另外一个是sheetName的值
filePath = "D:\\test\\web-project\\5ke\\testdata.xlsx"
sheetName = "Sheet1"
data = ExcelUtil(filePath, sheetName)
print data.dict_data()

# 测试数据
testData = data.dict_data()
print testData
@ddt.ddt
class Bolg(unittest.TestCase):
u'''登录博客'''
def setUp(self):
self.driver = webdriver.Firefox()
url = "https://passport.cnblogs.com/user/signin"
self.driver.get(url)
self.driver.implicitly_wait(30)
def login(self, username, psw):
u'''这里写了一个登录的方法,账号和密码参数化'''
self.driver.find_element_by_id("input1").send_keys(username)
self.driver.find_element_by_id("input2").send_keys(psw)
self.driver.find_element_by_id("signin").click()
time.sleep(3)
def is_login_sucess(self):
u'''判断是否获取到登录账户名称'''
try:
text = self.driver.find_element_by_id("lnk_current_user").text
print text
return True
except:
return False
@ddt.data(*testData)
def test_login(self, data):
u'''登录案例参考'''
print ("当前测试数据%s"%data)
# 调用登录方法
self.login(data["username"], data["password"])
# 判断结果
result = self.is_login_sucess()
self.assertTrue(result)
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()

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 D
OM 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

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."""
'''翻译：检查页面的title与期望值是都完全一致，如果完全一致，返回Ture,否则返回Flase'''
def __init__(self, title):
self.title = title
def __call__(self, driver):
return self.title == driver.title

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Firefox()
driver.get("http://www.cnblogs.com/yoyoketang")
# 判断title完全等于
title = EC.title_is(u'上海-悠悠 - 博客园')
print title(driver)
# 判断title包含
title1 = EC.title_contains(u'上海-悠悠')
print title1(driver)
# 另外一种写法,交流QQ群：232607095
r1 = EC.title_is(u'上海-悠悠 - 博客园')(driver)
r2 = EC.title_contains(u'上海-悠悠')(driver)
print r1
print r2

class text_to_be_present_in_element(object):
""" An expectation for checking if the given text is present in the
specified element.
locator, text
"""
'''翻译：判断元素中是否存在指定的文本，参数：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

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Firefox()
url = "https://www.baidu.com"
driver.get(url)
locator = ("name", "tj_trnuomi")
text = u"糯米"
result = EC.text_to_be_present_in_element(locator, text)(driver)
print result
# 交流QQ群：232607095
# 下面是失败的案例
text1 = u"糯米网"
result1 = EC.text_to_be_present_in_element(locator, text1)(driver)
print result1
locator2 = ("id", "su")
text2 = u"百度一下"
result2 = EC.text_to_be_present_in_element_value(locator2, text2)(drive
r)
print result2

class alert_is_present(object):
""" Expect an alert to be present."""
"""判断当前页面的alert弹窗"""
def __init__(self):
pass
def __call__(self, driver):
try:
alert = driver.switch_to.alert
alert.text
return alert
except NoAlertPresentException:
return False

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Firefox()
url = "https://www.baidu.com"
driver.get(url)
mouse = WebDriverWait(driver, 10).until(lambda x: x.find_element("link text", "设置"))
ActionChains(driver).move_to_element(mouse).perform()
WebDriverWait(driver, 10).until(lambda x: x.find_element("link text", "搜索设置")).click()
#　选择设置项
s = WebDriverWait(driver, 10).until(lambda x: x.find_element("id", "nr"))
Select(s).select_by_visible_text("每页显示50条")
# 点保存按钮
js = 'document.getElementsByClassName("prefpanelgo")[0].click();'
driver.execute_script(js)
# 判断弹窗结果 交流QQ群: 232607095
result = EC.alert_is_present()(driver)
if result:
print result.text
result.accept()
else:
print "alert 未弹出！"

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)

# coding:utf-8
from selenium import webdriver
from selenium.common.exceptions import *   # 导入所有的异常类
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
class Yoyo(object):
"""基于原生的selenium框架做了二次封装."""
def __init__(self):
"""启动浏览器参数化，默认启动firefox."""
self.driver = webdriver.Firefox()
def get(self, url):
'''使用get打开url'''
self.driver.get(url)
def find_element(self, locator, timeout=10):
'''定位元素方法封装'''
element = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_element_located(locator))
return element
def click(self, locator):
'''点击操作'''
element = self.find_element(locator)
element.click()
def send_keys(self, locator, text):
'''发送文本，清空后输入'''
element = self.find_element(locator)
element.clear()
element.send_keys(text)
if __name__ == "__main__":
d = Yoyo()  # 启动firefox
d.get("https://www.baidu.com")
input_loc = ("id", "kw")
d.send_keys(input_loc, "yoyo")   # 输入搜索内容
button_loc = ("id", "su")
d.click(button_loc)           # 点击搜索按钮

# coding:utf-8
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.select import Select
from selenium.common.exceptions import *   # 导入所有的异常类
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
'''
下面这三行代码是为了避免python2中文乱码问题,python3忽略
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
'''
def browser(browser='firefox'):
"""
打开浏览器函数，"firefox"、"chrome"、"ie"、"phantomjs"
"""
try:
if browser == "firefox":
driver = webdriver.Firefox()
return driver
elif browser == "chrome":
driver = webdriver.Chrome()
return driver
elif browser == "ie":
driver = webdriver.Ie()
return driver
elif browser == "phantomjs":
driver = webdriver.PhantomJS()
return driver
else:
print("Not found this browser,You can enter 'firefox', 'chrome', 'ie' or 'phantomjs'")
except Exception as msg:
print "%s" % msg
class Yoyo(object):
"""
基于原生的selenium框架做了二次封装.
"""
def __init__(self, driver):
"""
启动浏览器参数化，默认启动firefox.
"""
self.driver = driver
def open(self, url, t='', timeout=10):
'''
使用get打开url后，最大化窗口，判断title符合预期
Usage:
driver = Yoyo()
driver.open(url,t='')
'''
self.driver.get(url)
self.driver.maximize_window()
try:
WebDriverWait(self.driver, timeout, 1).until(EC.title_contains(t))
except TimeoutException:
print("open %s title error" % url)
except Exception as msg:
print("Error:%s" % msg)
def find_element(self, locator, timeout=10):
'''
定位元素，参数locator是元祖类型
Usage:
locator = ("id","xxx")
driver.find_element(locator)
'''
element = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_element_located(locator))
return element
def find_elements(self, locator, timeout=10):
'''定位一组元素'''
elements = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_all_elements_located(locator))
return elements
def click(self, locator):
'''
点击操作
Usage:
locator = ("id","xxx")
driver.click(locator)
'''
element = self.find_element(locator)
element.click()
def send_keys(self, locator, text):
'''
发送文本，清空后输入
Usage:
locator = ("id","xxx")
driver.send_keys(locator, text)
'''
element = self.find_element(locator)
element.clear()
element.send_keys(text)
def is_text_in_element(self, locator, text, timeout=10):
'''
判断文本在元素里,没定位到元素返回False，定位到返回判断结果布尔值
result = driver.text_in_element(locator, text)
'''
try:
result = WebDriverWait(self.driver, timeout, 1).until(EC.text_to_be_present_in_element(locator, text))
except TimeoutException:
print "元素没定位到："+str(locator)
return False
else:
return result
def is_text_in_value(self, locator, value, timeout=10):
'''
判断元素的value值，没定位到元素返回false,定位到返回判断结果布尔值
result = driver.text_in_element(locator, text)
'''
try:
result = WebDriverWait(self.driver, timeout, 1).until(EC.text_to_be_present_in_element_value(locator, value))
except TimeoutException:
print "元素没定位到："+str(locator)
return False
else:
return result
def is_title(self, title, timeout=10):
'''判断title完全等于'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.title_is(title))
return result
def is_title_contains(self, title, timeout=10):
'''判断title包含'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.title_contains(title))
return result
def is_selected(self, locator, timeout=10):
'''判断元素被选中，返回布尔值,'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.element_located_to_be_selected(locator))
return result
def is_selected_be(self, locator, selected=True, timeout=10):
'''判断元素的状态，selected是期望的参数true/False
返回布尔值'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.element_located_selection_state_to_be(locator, selected))
return result
def is_alert_present(self, timeout=10):
'''判断页面是否有alert，有返回alert(注意这里是返回alert,不是True)
没有返回False'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.alert_is_present())
return result
def is_visibility(self, locator, timeout=10):
'''元素可见返回本身，不可见返回Fasle'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.visibility_of_element_located(locator))
return result
def is_invisibility(self, locator, timeout=10):
'''元素可见返回本身，不可见返回True，没找到元素也返回True'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.invisibility_of_element_located(locator))
return result
def is_clickable(self, locator, timeout=10):
'''元素可以点击is_enabled返回本身，不可点击返回Fasle'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.element_to_be_clickable(locator))
return result
def is_located(self, locator, timeout=10):
'''判断元素有没被定位到（并不意味着可见），定位到返回element,没定位到返回False'''
result = WebDriverWait(self.driver, timeout, 1).until(EC.presence_of_element_located(locator))
return result
def move_to_element(self, locator):
'''
鼠标悬停操作
Usage:
locator = ("id","xxx")
driver.move_to_element(locator)
'''
element = self.find_element(locator)
ActionChains(self.driver).move_to_element(element).perform()
def back(self):
"""
Back to old window.
Usage:
driver.back()
"""
self.driver.back()
def forward(self):
"""
Forward to old window.
Usage:
driver.forward()
"""
self.driver.forward()
def close(self):
"""
Close the windows.
Usage:
driver.close()
"""
self.driver.close()
def quit(self):
"""
Quit the driver and close all the windows.
Usage:
driver.quit()
"""
self.driver.quit()
def get_title(self):
'''获取title'''
return self.driver.title
def get_text(self, locator):
'''获取文本'''
element = self.find_element(locator)
return element.text
def get_attribute(self, locator, name):
'''获取属性'''
element = self.find_element(locator)
return element.get_attribute(name)
def js_execute(self, js):
'''执行js'''
return self.driver.execute_script(js)
def js_focus_element(self, locator):
'''聚焦元素'''
target = self.find_element(locator)
self.driver.execute_script("arguments[0].scrollIntoView();", target)
def js_scroll_top(self):
'''滚动到顶部'''
js = "window.scrollTo(0,0)"
self.driver.execute_script(js)
def js_scroll_end(self):
'''滚动到底部'''
js = "window.scrollTo(0,document.body.scrollHeight)"
self.driver.execute_script(js)
def select_by_index(self, locator, index):
'''通过索引,index是索引第几个，从0开始'''
element = self.find_element(locator)
Select(element).select_by_index(index)
def select_by_value(self, locator, value):
'''通过value属性'''
element = self.find_element(locator)
Select(element).select_by_value(value)
def select_by_text(self, locator, text):
'''通过文本值定位'''
element = self.find_element(locator)
Select(element).select_by_value(text)
if __name__ == '__main__':
# if下面的代码都是测试调试的代码，自测内容
driver = browser()
driver_n = Yoyo(driver)  # 返回类的实例：打开浏览器
driver_n.open("http://www.cnblogs.com/yoyoketang/")  # 打开url，顺便判断打开的页面对不对
input_loc = ("id", "kw")
print driver_n.get_title()
#　el = driver_n.find_element(input_loc)
# driver_n.send_keys(input_loc, "yoyo")
# button_loc = ("id", "su")
# driver_n.click(button_loc)
# print driver_n.text_in_element(("name", "tj_trmap"), "地图")
# set_loc = ("link text", "设置")
# driver_n.move_to_element(set_loc)

# coding:utf-8
from xxx.yoyo_selenium import Yoyo  # 导入4.11二次封装的类
login_url = "https://passport.cnblogs.com/user/signin"
class LoginPage(Yoyo):
# 定位器，定位页面元素
username_loc = ("id", 'input1')  # 输入账号
password_loc = ("id", 'input2')
submit_loc = ("id", 'signin')
remember_loc = ('id', 'remember_me')
retrieve_loc = ('link text', '找回')
reset_loc = ('link text', '重置')
register_loc = ('link text', '立即注册')
feedback_loc = ('link text', '反馈问题')
def input_username(self, username):
'''输入账号框'''
self.send_keys(self.username_loc, username)
def input_password(self, password):
'''输入密码框'''
self.send_keys(self.password_loc, password)
def click_submit(self):
'''登录按钮'''
self.click(self.submit_loc)
def click_remember_live(self):
'''下次记住登录'''
self.click(self.remember_loc)
def click_retrieve(self):
'''找回密码'''
self.click(self.retrieve_loc)
def click_reset(self):
'''重置密码'''
self.click(self.reset_loc)
def click_register(self):
'''注册新账号'''
self.click(self.register_loc)
def click_feedback(self):
'''反馈问题'''
self.click(self.feedback_loc)
def login(self, username, password):
'''登录方法'''
self.input_username(username)
self.input_password(password)
self.click_submit()

# coding:utf-8
import unittest
from xxx.yoyo_selenium import browser
from xxx.xxx import LoginPage, login_url
class Login_test(unittest.TestCase):
u'''登录页面的case'''
def setUp(self):
self.driver = browser()
self.login= LoginPage(self.driver)  #login参数是LoginPage的实例
        self.login.open(login_url)
def login_case(self, username, psw, expect=True):
'''登录用例的方法,'''
# 第1步：输入账号
        self.login.input_username(username)
# 第2步: 输入密码
        self.login.input_password(psw)
# 第3步：点登录按钮
        self.login.click_submit()
# 第4步：测试结果,判断是否登录成功
result = self.login.is_text_in_element(("id","lnk_current_user"),"上海-悠悠")
# 第5步：期望结果
expect_result = expect
self.assertEqual(result, expect_result)
def test_login01(self):
u'''输入正确账号密码'''
self.login_case("xx", "xx", True)
def test_login02(self):
u'''输入错误账号密码'''
self.login_case("xx", "xx", False)
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()

# coding:utf-8
from selenium import webdriver
driver = webdriver.Firefox()
# 截图功能
def get_screen():
'''截图'''
import time
nowTime = time.strftime("%Y_%m_%d_%H_%M_%S")
driver.get_screenshot_as_file('%s.jpg' % nowTime)
# 自动截图装饰器
def screen(func):
'''截图装饰器'''
def inner(*args, **kwargs):
try:
f = func(*args, **kwargs)
return f
except:
get_screen()  # 失败后截图
raise
return inner
@screen
def search(driver):
driver.get("https://www.baidu.com")
driver.find_element_by_id("kw11").send_keys("python")  # 此行运行失败的
driver.find_element_by_id("su").click()
search(driver)  # 执行search

Decorators without Arguments
If we create a decorator without arguments, the function to be decorated
is passed to the constructor, and the __call__() method is called
whenever the decorated function is invoked:
class decoratorWithoutArguments(object):
def __init__(self, f):
"""
If there are no decorator arguments, the function
to be decorated is passed to the constructor.
"""
print "Inside __init__()"
self.f = f
def __call__(self, *args):
"""
The __call__ method is not called until the
decorated function is called.
"""
print "Inside __call__()"
self.f(*args)
print "After self.f(*args)"
@decoratorWithoutArguments
def sayHello(a1, a2, a3, a4):
print 'sayHello arguments:', a1, a2, a3, a4

Decorators with Arguments
Now let's modify the above example to see what happens when we add arguments to the decorator:
class decoratorWithArguments(object):
def __init__(self, arg1, arg2, arg3):
"""
If there are decorator arguments, the function
to be decorated is not passed to the constructor!
"""
print "Inside __init__()"
self.arg1 = arg1
self.arg2 = arg2
self.arg3 = arg3
def __call__(self, f):
"""
If there are decorator arguments, __call__() is only called
once, as part of the decoration process! You can only give
it a single argument, which is the function object.
"""
print "Inside __call__()"
def wrapped_f(*args):
print "Inside wrapped_f()"
print "Decorator arguments:", self.arg1, self.arg2, self.arg3
f(*args)
print "After f(*args)"
return wrapped_f
@decoratorWithArguments("hello", "world", 42)
def sayHello(a1, a2, a3, a4):
print 'sayHello arguments:', a1, a2, a3, a4

# coding:utf-8
from selenium import webdriver
class Screen(object):
u'''这个应该截图功能的装饰器'''
def __init__(self, driver):
self.driver = driver
def __call__(self, f):
def inner(*args):
try:
return f(*args)
except:
import time
nowTime = time.strftime("%Y_%m_%d_%H_%M_%S")
self.driver.get_screenshot_as_file('%s.jpg' % nowTime)
raise
return inner
# 以下是装饰器与unittest结合的案例
import unittest
class Test(unittest.TestCase):
driver = webdriver.Firefox()  # 全局参数driver
def setUp(self):
self.driver.get("https://www.baidu.com")
@Screen(driver)
def test01(self):
u'''这个是失败的案例'''
self.driver.find_element_by_id("11kw").send_keys("python")
self.driver.find_element_by_id("su").click()
@Screen(driver)
def test_02(self):
u'''这个是通过的案例'''
self.driver.find_element_by_id("kw").send_keys("yoyo")
self.driver.find_element_by_id("su").click()
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()

# coding:utf-8
from selenium import webdriver
import time
# 启动第一个浏览器
driver1 = webdriver.Firefox()
driver1.get("https://www.baidu.com")
print(driver1.title)
# 启动第二个浏览器
driver2 = webdriver.Firefox()
driver2.get("http://www.cnblogs.com/yoyoketang/")
print(driver2.title)
# 关掉第一个浏览器窗口
driver1.quit()
# 点首页"博客园"按钮
driver2.find_element_by_id("blog_nav_sitehome").click()
time.sleep(2)
print(driver2.title)

# coding:utf-8
from selenium import webdriver
def browser(browser='firefox'):
'''
open browser "firefox"、"chrome"、"ie"、"phantomjs"
usage:
driver = broswer("chrome")
'''
try:
if browser == "firefox":
driver = webdriver.Firefox()
return driver
elif browser == "chrome":
driver = webdriver.Chrome()
return driver
elif browser == "ie":
driver = webdriver.Ie()
return driver
elif browser == "phantomjs":
driver = webdriver.PhantomJS()
return driver
else:
print("Not found browser!You can enter 'firefox', 'chrome', 'ie' or 'phantomjs'")
except Exception as msg:
print "open browser error:%s" % msg
if __name__ == "__main__":
# 默认启动firefox
driver_firefox = browser()
driver_firefox.get("https://www.baidu.com")
print("open browser:%s" % driver_firefox.name)
print(driver_firefox.title)
# 启动第phantomjs
driver_pj = browser("phantomjs")
driver_pj.get("http://www.cnblogs.com/yoyoketang/")
print("open browser:%s" % driver_pj.name)
print(driver_pj.title)