前面讲到unittest里面setUp可以在每次执行用例前执行，这样有效的减少了代码量，但是有个弊端，比如打开浏览器操作，每次执行用例时候都会重新打开，这样就会浪费很多时间。于是就想是不是可以只打开一次浏览器，执行完用例再关闭呢？这就需要用到装饰器（@classmethod）来解决了。
一、装饰器
1.用setUp与setUpClass区别
setup():每个测试case运行前运行
teardown():每个测试case运行完后执行
setUpClass():必须使用@classmethod 装饰器,所有case运行前只运行一次
tearDownClass():必须使用@classmethod装饰器,所有case运行完后只运行一次
2.@是修饰符，classmethod是python里的类方法
二、执行顺序
1.用类方法写几个简单case，可以对比这篇：Selenium2+python自动化52-unittest执行顺序
# coding:utf-8
import unittest
import time
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
print "start!"
@classmethod
def tearDownClass(cls):
time.sleep(1)
print "end!"
def test01(self):
print "执行测试用例01"
def test03(self):
print "执行测试用例03"
def test02(self):
print "执行测试用例02"
def addtest(self):
print "add方法"
if __name__ == "__main__":
unittest.main()
2.从执行结果可以看出，前置和后置在执行用例前只执行了一次。
start!
执行测试用例01
执行测试用例02
执行测试用例03
...end!
----------------------------------------------------------------------
Ran 3 tests in 1.001s
三、selenium实例
1.可以把打开浏览器操作放到前置setUpClass(cls)里，这样就可以实现打开一次浏览器，执行多个case了
# coding:utf-8
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
import unittest
class BolgHome(unittest.TestCase):
u'''博客首页'''
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Firefox()
url = "http://www.cnblogs.com/yoyoketang/"
cls.driver.get(url)
cls.driver.implicitly_wait(30)
@classmethod
def tearDownClass(cls):
cls.driver.quit()
def test_01(self):
u'''验证元素存在：博客园'''
locator = ("id", "blog_nav_sitehome")
text = u"博客园"
result = EC.text_to_be_present_in_element(locator, text)(self.driver)
self.assertTrue(result)
def test_02(self):
u'''验证元素存在：首页'''
locator = ("id", "blog_nav_myhome")
text = u"首页"
result = EC.text_to_be_present_in_element(locator, text)(self.driver)
self.assertTrue(result)
if __name__ == "__main__":
unittest.main()
#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/4'
# decorator.py 装饰器
# 装饰器: 本质是函数, 用于装饰其他函数, 附加一些本身所没有的功能
# 函数就是变量
def num():
print("num")
num()
num = 1 # 函数就是变量
# num() # num的引用被指向1,不能再调用
# ========================================
# 高阶函数
def func_1():
print("func_1")
def func_2(func): # 接收函数变量
func()
func_2(func_1) # => func_1
# ========================================
# 闭包
def func_3(line):
# 闭包: 用于代码封装 和 复用
def comp(value): # 嵌套函数: 函数里再嵌套一个函数
# 函数set_line执行完(生命周期结束), 自由变量(line)仍存活于包裹内
if value >= line:
print("{} >= {}".format(value, line))
else:
print("{} < {}".format(value, line))
return comp
f = func_3(60) # 调用函数A(set_line()),返回函数B(cmp()),这个函数B就叫闭包
f(89) # => 89 >= 60
f(59) # => 59 < 60
# ========================================
# 装饰器, 在不修改my_average()代码的情况下,为其添加了一些功能(wrapper())
def dec_1(func):
def wrapper(num1, num2):
# --- 附加功能 ---
if num2 == 0:
print("num2 值不能为0")
return func(num1, num2)
return wrapper
# 普通调用方式
def average_1(num1, num2):
return num1 / num2
average_1 = dec_1(average_1)
print(average_1(5, 3)) # => 1.6666666666666667
# 使用@语法糖的方式
@dec_1 # (sum = dec(sum))
def sum_1(num1, num2):
return num1 + num2
print(sum_1(5, 3)) # => 8
# ========================================
# 能接收任何参数的通用装饰器
def dec_2(func):
def wrapper(*arg, **kwargs):
# --- 附加功能 ---
print("loging i ...")
return func(*arg, **kwargs)
return wrapper
@dec_2
def average_2(num1, num2):
return num1 / num2
print(average_2(5, 3)) # => loging i ... => 1.6666666666666667
@dec_2
def sum_2(*args):
return sum(args)
print(sum_2(5, 3, 2, 1)) # => loging i ... => 11
# ========================================
# 能接收不同参数的装饰器
def auth(auth_type): # 在外面套一层
def dec_3(func):
def wrapper(*arg, **kwargs):
# --- 附加功能 ---
if auth_type == "admin":
print("你是管理员")
elif auth_type == "user":
print("你是普通用户")
else:
print("你是外星人吗?")
return func(*arg, **kwargs)
return wrapper
return dec_3
# 普通调用方式
@auth(auth_type="admin")
def average_3(*arg):
return sum(arg) / len(arg)
print(average_3(1, 2, 3, 4, 5)) # => 你是管理员 => 3.0
@auth(auth_type="user")
def sum_3(*arg):
return sum(arg)
print(sum_3(5, 3, 2, 1)) # => 你是普通用户 => 11
# ========================================
# 使用多个装饰器
@dec_1
@dec_2
@auth(auth_type="admin")
def average_2(num1, num2):
return num1 / num2
# 执行顺序dec_1 => dec_2 => auth => average_2
print(average_2(5, 3)) # => loging i ... => 你是管理员 => 1.6666666666666667
---------------------
首先，程序开始从guoguo（）执行了，结果它发现该函数前面有个@，就知道该函数被装饰了，那就先去看看装饰了哪些功能吧。
然后，该函数就作为参数进入到decorate（）中，返回另一个函数test。
最后，test（）中就把需要添加给guoguo（）的功能写在此处，如果需要guoguo（）的结果，就在需要的地方调用即可。
这就是我理解的装饰器，概况来说，就是把需要装饰的函数当做装饰器函数的参数，然后返回一个新函数，在新函数中实现装饰功能。