软件测试肖sir__python之ui自动化封装和单元测试框架

python之selenium
一、ui自动化封装
题目：
ui自动化用例封装案例：
1、将论坛的登录还有点击模块管理 通过类来进行封装(给实参)
2、将论坛的登录还有点击模块管理 用例封装(给形参)且通过类的传递完成调用

案例1：按函数顺序来写
class Discuz():
def jiazai(self,url):
global d
d=webdriver.Chrome()
d.get(url)
def login(self,username, password):
d.find_element_by_id(“ls_username”).send_keys(username)
d.find_element_by_id(“ls_password”).send_keys(password)
d.find_element_by_xpath("/html/body/div[5]/div/div[1]/form/div/div/table/tbody/tr[2]/td[3]/button/em").click()
time.sleep(4)
def module(self,title,message):
d.find_element_by_partial_link_text(“默认版”).click()
s = d.find_element_by_id(“newspecial”)
ActionChains(d).move_to_element(s).perform()
time.sleep(3)
d.find_element_by_link_text(“发表帖子”).click()
d.find_element_by_id(“subject”).send_keys(title)
ww = d.find_element_by_id(“e_iframe”)
d.switch_to_frame(ww)
time.sleep(3)
d.find_element_by_css_selector("[contenteditable=true]").send_keys(message)
d.switch_to_default_content()
d.find_element_by_id(“postsubmit”).click()
d.close()
if name == ‘main’:
a=Discuz()
a.jiazai(“http://192.168.152.128/bbs/forum.php”)
a.login(“admin”, “123456”)
a.module(“学习软件测试”,“1.软件测试基础2.自动化测试”)

案例2：
from selenium import webdriver
from time import sleep

class Lt():
def init(self):
self.d=webdriver.Chrome()
self.d.get(“http://cms.duoceshi.cn/cms/manage/login.do”)
self.d.maximize_window()
self.d.implicitly_wait(5)
def login(self,zh,mi):
self.d.find_element_by_id(“userAccount”).send_keys(zh)
self.d.find_element_by_id(‘loginPwd’).send_keys(mi)
sleep(2)
self.d.find_element_by_id(‘loginBtn’).click()

def q(self):
    self.login("admin",'123456')
    sleep(3)
    self.d.find_element_by_link_text("退出").click()
    sleep(5)
    self.d.close()

if name == ‘main’:
l=Lt()
# l.login(‘admin’,123456)
l.q()

===========================================
二、单元测试框架
unittest 单元测试框架
python中unittest 单元测试框架是自带标准库；
作用：管理和组织测试用例
常用的测试框架：unittest 、pytest

案例1：第一种调用方法
调用所有所有用例
知识点： （1）unittest.main() 调用所有所有用例
（2）test开头的用例
（3）导入unittest模块
import unittest #导入unitest 模块
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
print(“类开始”)
@classmethod
def tearDownClass(cls) -> None:
print(“类的结束”)
def setUp(self) -> None:
print(“方法的开始”)
def tearDown(self) -> None:
print(“方法的结束”)
def test001(self):
print(1111)
def test005(self):
print(555)
def test003(self):
print(‘333’)
def testa(self):
print(“aaa”)
def testA(self):
print(“AA”)
def abc(self):
print(“没有test开头”)
if name == ‘main’:
unittest.main()

备注：
（1）只运行以test开头的用例
（2）test 后面运行的顺序是以ascll 码为标准：0-9，A-Z，a-z
（3）类的开始和类的结束 只会运行一次
（4）方法的开始和方法的结束 每一次用例都会执行

案例2：调用部分用例
unittest.Testsuite 套件
addTest 添加单个用例
addTests 添加多个用例
unittest.texttestrunner 创建执行多象
run 方法运行

import unittest #导入unitest 模块
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
print(“类开始”)
@classmethod
def tearDownClass(cls) -> None:
print(“类的结束”)
def setUp(self) -> None:
print(“方法的开始”)
def tearDown(self) -> None:
print(“方法的结束”)
def test001(self):
print(1111)
def test005(self):
print(555)
def test003(self):
print(‘333’)
def testa(self):
print(“aaa”)
def testA(self):
print(“AA”)
def abc(self):
print(“没有test开头”)
if name == ‘main’:
tj=unittest.TestSuite() #创建一个容器
# tj.addTest(Test(“test001”)) #在套件中添加用例 #添加单个用例
tj.addTests([Test(“test001”),Test(“testa”)])
run=unittest.TextTestRunner() #创建一个执行对象
run.run(tj)#通过对象调用run方法来运行添加的用例

案例3:搜索路径的方法
知识点：（1）unittest.TestLoader().discover(start_dir=path,pattern=“cs*.py”) 路径搜索
（2）unittest.TextTestRunner() 创建执行对象
（3）run方法运行

import unittest #导入unitest 模块
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
print(“类开始”)
@classmethod
def tearDownClass(cls) -> None:
print(“类的结束”)
def setUp(self) -> None:
print(“方法的开始”)
def tearDown(self) -> None:
print(“方法的结束”)
def test001(self):
print(1111)
def test005(self):
print(555)
def test003(self):
print(‘333’)
def testa(self):
print(“aaa”)
def testA(self):
print(“AA”)
def abc(self):
print(“没有test开头”)
if name == ‘main’:
path=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
d=unittest.TestLoader().discover(start_dir=path,pattern=“cs*.py”)
r=unittest.TextTestRunner()
r.run(d)

（4）生成自动化测试报告
import unittest #导入unitest 模块
from hz1201.HTMLTestRunner3_New import HTMLTestRunner
from time import *
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
print(“类开始”)
@classmethod
def tearDownClass(cls) -> None:
print(“类的结束”)
def setUp(self) -> None:
print(“方法的开始”)
def tearDown(self) -> None:
print(“方法的结束”)
def test001(self):
print(1111)
def test005(self):
print(555)
def test003(self):
print(‘333’)
def testa(self):
print(“aaa”)
def testA(self):
print(“AA”)
def abc(self):
print(“没有test开头”)
if name == ‘main’:
bgpath=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
path=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
d=unittest.TestLoader().discover(start_dir=path,pattern=“cs*.py”)
new=strftime(’%y-%m-%d %H-%M-%S’)
filename=bgpath+"/"+str(new)+’_ui.html’
f=open(filename,“wb”)
r=HTMLTestRunner(stream=f,
title=“ui自动化测试”,description=“用例执行情况”,tester=“hz12”
)
r.run(d)

======================================
一、unittst框架的作用
当我们写的用例越来越多时，我们就需要考虑用例编写的规范与组织，以便于后期的维护，而unittest正是这样一款工具
二、unittest是Python自带的标准库中的模块，其中包括：
1、TestCase类
2、TestSuite类
3、TestLoader类
4、TextTestRunner类
5、TextTestResult类
6、TestFixture类
解释下：
TestCase：
一个Testcase的实例就是一个测试用例，测试用例就是一个完整的测试流程，包括初始化setUp、运行run、测试后的还原tearDown
TestSuite：
对一个功能的测试往往需要多测试用例的，可以把多的测试用例集合在一起执行，这就是TestSuite的概念。
常用addTest()方法将一个测试用例添加到测试套件中
TextTestRunner：
是用来执行测试用例的，其中的run(test)用来执行TestSuite/TestCase。测试的结果会保存在TextTestResult实例中
TestFixture：
测试准备前要做的工作和测试执行完后要做的工作.包括setUp()和tearDown()。通过覆盖TestCase的setUp和tearDown来实现。
TestLoader：
是用来搜索所有以test开头的测试用例，然后将其加入到testsuite中
图形化解释：如下图

三、框架的组成
在写测试类以及测试用例时要规定一个命名习惯，一般测试类可以以Test开头，也可以以Test结尾。测试用例一般是以test开头。
eg：结构如下：
import unittest #导入unittest包
#创建测试类：从unittest.TestCase继承
classRomanNumeralConverterTest(unittest.TestCase):
def setUp(self): #初始化测试环境
def tearDown(self): #还原测试环境
def test_case(self):测试用例
四\百度案例
from selenium import webdriver
import unittest
import time
class x(unittest.TestCase):
#setUp:用于设置初始化环境的，该类中的方法执行时都会先执行setup中
#代码如：打开浏览器、变量赋值、连接数据库等工作
def setUp(self):
self.dr=webdriver.Chrome()
self.dr.maximize_window()
self.dr.implicitly_wait(20)#智能等待，sleep机械等待
self.dr.get(‘http://www.baidu.com’)

#编写实际用例的地方
#搜索多测师
def test_caseA(self):
self.dr.find_element_by_id(‘kw’).send_keys('多测师’)
sleep(3)

#搜索达内
def test_case3(self):
self.dr.find_element_by_id(‘kw’).send_keys(’达内’)
sleep(3)

#搜索北大青鸟
def test_case2(self):
self.dr.find_element_by_id(‘kw’).send_keys(’北大青鸟’)
sleep(3)
#用例执行完，还有测试环境如：退出登录、断开数据库、关闭浏览器
def tearDown(self):
self.dr.quit()#关闭所有窗口
if name == ‘main’:
unittest.main()#
#unittest.main():使用它可以将一个单元测试模块变为可直接运行的测试脚本，main()方法使用TestLoader类来搜索所有包含在该模块中以“test”命名开头的测试方法，并自动执行
注意：pycharm工具默认执行方式为unittests方式
五、组织用例集
这里我们假设，脚本当中有多个TestCase如test_case1，test_case2…，那我们应该怎样去控制它们的执行顺序
#执行方案一：
if name == ‘main’:
unittest.main()#
注：这里它搜索所有以test开头的测试用例方法，根据ASCII码的顺序加载测试用例， 数字与字母的顺序为：0-9，A-Z，a-z
#执行方案二：
if name == ‘main’:
suite=unittest.TestSuite()#构造测试容器（先实例化测试套件）
suite.addTest(baidu(‘test’))#添加用例
suite.addTest(baidu(‘test_jd’))
#suite.addTests([foo(‘test_dcs’),foo(‘test_dn’),foo(‘test_bdqn’)])
run=unittest.TextTestRunner()#获取运行方法
run.run(suite)
注：执行的顺序是用例的加载顺序，比如这里是先执行2后执行1。
#执行方案三：执行顺序和方案一相同(路径不要太深，复杂)
在方案2中，如果我们有成百上千个用例的话，一个一个add进去，是不太现实的，那么我们可以用defaultTestLoader来加载，该添加方法不过当前py文件下有多少个用例有多少个类，都可以执行
if name == ‘main’:
test_dir = ‘./’
discover=unittest.defaultTestLoader.discover(test_dir,pattern=’*d3.py’)
runner = unittest.TextTestRunner()
runner.run(discover)
方案4就是:添加测试报告

自动化用例编写注意点：
1、一个自动化脚本就是一个完整的场景：从开始—执行过程—结束（退出）
2、一个自动化脚本只验证一个功能点，不要试图把所有功能都写在一个用例中
3、编写自动化用例尽量是正常场景，避免异常场景（用名不填验证登录）
4、自动动化用例直接尽量保证独立性，不要造成一个用例与多个用例产出数据上或业务上的关联，这会给后期带来用例维护上的不便
5、自动化用例的断言，只针对需要断言的地方进行断言（重要环节），没必要在每个个环境进行断言验证

==========================
案例：
import unittest
from selenium import webdriver
from time import *
from hz1201.HTMLTestRunner3_New import HTMLTestRunner
class Bd(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
pass
@classmethod
def tearDownClass(cls) -> None:
pass
def setUp(self) -> None:
self.d=webdriver.Chrome()
self.d.get(“http://www.baidu.com”)
self.d.maximize_window()
self.d.implicitly_wait(5)
def tearDown(self) -> None:
sleep(5)
self.d.close()
def test_001(self):
self.d.find_element_by_id(“kw”).send_keys(“python”)
def test_002(self):
self.d.find_element_by_id(“kw”).send_keys(“html”)
def test_a(self):
self.d.find_element_by_id(“kw”).send_keys(“mysql”)
def test_A(self):
self.d.find_element_by_id(“kw”).send_keys(“linux”)
def no(self):
self.d.find_element_by_id(“kw”).send_keys(“no”)
if name == ‘main’:
# unittest.main()#第一种方法
# s=unittest.TestSuite()
# s.addTests([Bd(“test_A”),Bd(“test_001”)])
# r=unittest.TextTestRunner()
# r.run(s) #第二种调用方法
# p=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
# d=unittest.defaultTestLoader.discover(start_dir=p,pattern=“kj*.py”)
# r=unittest.TextTestRunner()
# r.run(d) #第三种
bg=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
p=r"C:\Users\Administrator\PycharmProjects\dcshz12\hz1201"
d=unittest.defaultTestLoader.discover(start_dir=p,pattern=“kj*.py”)
new=strftime("%y-%m-%d %H-%M-%S")
file=bg+"/"+str(new)+"_ui.html"
f=open(file,“wb”)
r=HTMLTestRunner(stream=f,title=“百度UI自动化测试报告”,description=“用例执行情况”
,tester=“hz”)
r.run(d)
f.close()