一、UnitTest
1.1.框架
框架为解决一类事情的功能集合
1.2.UnitTest框架介绍
1).UnitTest是Python自带的一个单元测试框架，用它来做单元测试
2).第三方框架：pytest
3).对于测试来说，unitteSt框架的作用是自动化脚本（用例代码）执行框架（使用UnitTest框架来管理运行多个测试用例)
1.3.UnitTest框架的特点
1).能够组织多个用例去执行
2).提供丰富的断言方法(让程序代码代替人工自动的判断预期结果和实际结果是否相符）
3).能够生成测试报告
1.4.UnitTest核心要素
1).TestCase(最核心的模块)
1.1).测试用例，不是手工和自动化中的测试用例
1.2).作用：每个TestCase（测试用例）都是一个代码文件，在这个代码文件中，书写真正的用例代码
2).TestSuite
测试套件，用来管理组装多个TestCase的
3).TestRunner
测试执行/测试运行，用来执行TestSuite的
4).TestLoader
测试加载，功能是对TestSuite功能的补充，管理组装多个TestCase的
5).Fixture
测试夹具，书写在TestCase代码中，是一个代码结构，可以在每个方法执行前后都会执行的内容
二、TestCase(测试用例)
2.1.概念
是一个代码文件，在代码文件中来书写真正的用例代码
2.2.规则
代码文件的名字必须按照标识符的规则来书写(可以将代码的作用在文件的开头使用注释说明）
2.3.步骤
1).导包(import unittest)
2).自定义测试类
3).在测试类中书写测试方法
4).执行用例
2.4.代码
# 1.导包
import unittest
# 2.自定义测试类
class TestDemo(unittest.TestCase):
# 3.书写测试方法，即用例代码，因为没有真正的用例代码，使用print代替
# 书写要求：测试方法必须以test_开头（本质是以test开头）
def test_1(self):
print("测试方法1")
def test_2(self):
print("测试方法2")
# 4.执行用例(方法)
# 4.1 将光标放在类名的后边运行，会执行类中的所有的测试方法
# 4.2 将光标放在方法名的后边运行，只执行当前的方法三、TestSuite(测试套件) & TestRunner(测试执行)
3.1.TestSuite作用
TestSuite（测试套件）：管理打包组装TestCase（测试用例）文件
3.2.TestRunner作用
TestRunner（测试执行）：执行TestSuite（套件）
3.3.步骤
1).导包（unittest)
2).实例化套件对象
3).使用套件对象添加用例方法
4).实例化运行对象
5).使用运行对象去执行套件对象
3.4.代码
# 1.导包
import unittest
from test_TestCase import TestDemo
from test_TestCase01 import TestDemo1
# 2.实例化套件对象
suite = unittest.TestSuite()
# 3.使用套件对象添加用例方法
# 方式一，套件对象.addTest(测试类名（‘方法名’）） 建议测试类名和方法名直接去复制，不用手写
suite.addTest(TestDemo('test_1'))
suite.addTest(TestDemo('test_2'))
suite.addTest(TestDemo1('test_1'))
suite.addTest(TestDemo1('test_2'))
# 方式二，将一个测试类的所有方法进行添加，套件对象.addTest(unittest.makeSuite(测试类名））
# 缺点：makeSuite() 不会提示
suite.addTest(unittest.makeSuite(TestDemo))
suite.addTest(unittest.makeSuite(TestDemo1))
# 方式三，套件对象.addTests（(测试类名（‘方法名’）,..)/[测试类名（‘方法名’），..]）
suite.addTests([TestDemo('test_1'),TestDemo('test_2')])
# 4.实例化运行对象
runner = unittest.TextTestRunner()
# 5.使用运行对象去执行套件对象
# 运行对象.run(套件对象)
runner.run(suite)四、TestLoader(对TestSuite的补充)
4.1.作用
测试加载，作用和TestSuite作用一样，对TestSuite功能的补充
4.2.步骤
1).导包
2).实例化测试加载对象并添加用例--->得到一个suite对象
3).实例化运行对象
4).运行对象执行套件对象
4.3.代码
TestCae的代码文件一般放在单独的一个目录中!!!
# 1.导包
import unittest
# 2.实例化加载对象并添加用例
# unittest.TestLoader().discover('用例所在的路径','用例的代码文件名')
# 用例所在的路径，建议使用相对路径，用例的代码文件名可以使用*(任意多个任意字符)通配符
suite = unittest.TestLoader().discover('./case','test_*.py')
# # 3.实例化运行对象
# runner = unittest.TextTestRunner()
#
# # 4.执行
# runner.run(suite)
# 可以3，4步变为一步
unittest.TextTestRunner.run(suite)五、Fixture(测试夹具)
5.1.作用
测试夹具是一种代码结构，对一个测试用例环境的初始化和销毁就是一个Fixture（某些特定情况会自动执行)
5.2.级别
1).方法级别 (掌握)
1.1).作用：每个测试方法（用例代码）执行前后都会自动调用的结构
2).类级别 (掌握)
1.1).作用：在每个测试类中所有方法执行前后，都会自动调用的结构（在整个类中执行之前执行之后各一次)
3).模块级别(了解)
1.1).在每个代码文件执行前后执行的代码结构
1.2).模块级别的需要写在类的外边直接定义函数即可
5.3.注意
方法级别和类级别的前后方法，不需要同时出现，根据用例代码的需要自行选择使用
5.4.代码
import unittest
class TestLogin(unittest.TestCase):
def setUp(self):
"""每个测试方法执行之前都会先调用的方法"""
print('输入网址...')
def tearDown(self):
"""每个测试方法执行之后都会调用的方法"""
print('关闭网页')
@classmethod
def setUpClass(cls):
print('1.打开浏览器')
@classmethod
def tearDownClass(cls):
print('2.关闭浏览器')
def test_1(self):
print('请输入正确用户名密码验证码，点击登录 1')
def test_2(self):
print('请输入错误用户名密码验证码，点击登录 2')六、断言
6.1.概念
让程序代替人为判断测试程序执行结果是否符合预期结果的过程
6.2.好处
1).提高测试效率
2).实现自动化测试 (让脚本在无人值守状态下运行）
6.3.调用
在unittest中使用断言，都需要通过self.断言方法来试验
6.4.结果
1).true，用例通过
2).false，代码抛出异常，用例不通过
6.5.方法
1).assertEqual
作用：self.assertEqual(预期结果，实际结果）#判断实际结果与预期结果是否相等
1.如果相等，用例通过
2.如果不相等，用例不通过，抛出异常
2).assertNotEqual
作用：self.assertNotEqual(预期结果，实际结果）#判断实际结果与预期结果是否不相等
1.如果不相等，用例通过
2.如果相等，用例不通过，抛出异常
3).assertln
作用：self.assertln（预期结果，实际结果）#判断预期结果是否包含在实际结果中
1.包含，用例通过
2.不包含，用例不通过，抛出异常
4).assertNotln
作用：elf.assertln（预期结果，实际结果）#判断预期结果是否不包含在实际结果中
1.不包含，用例通过
2.包含，用例不通过，抛出异常
5).assertTrue
作用：self.assertTrue(判断表达式）#判断结果是否是true
1.如果是，用例通过
2.如果不是，用例不通过，抛出异常
6).assertFalse
作用：self.assertFalse(判断表达式)#判断结果是否为false
1.如果是，用例通过
2.如果不是，用例不通过，抛出异常
6.6.代码
import unittest
class TestAssert(unittest.TestCase):
def test_assert(self):
self.assertTrue(1 > 2) #失败
def test_assert2(self):
self.assertFalse(1 > 2) #成功
def test_assert3(self):
self.assertIn('a','abc') #成功
def test_assert4(self):
self.assertNotIn('a','abc') #失败
def test_assert5(self):
self.assertEqual(1,1) #成功
def test_assert6(self):
self.assertNotEquals(1,1) #失败七、参数化
7.1.概念
在测试方法中，使用变量代替具体的测试数据，然后使用传参的方法将测试数据传递给方法的变量
7.2.好处
相似的代码不需要多次书写
7.3.使用场景
1).测试数据一般放在json文件中
2).使用代码读取json文件，提取我们想要的数据--->[(),()]or[[],[]]
7.4.安装插件
unittest本身不支持参数化，需要安装插件---pip installparameterized
7.5.使用
1).导包unittest/parameterized
2).定义测试类
3).书写测试方法 (用到的测试数据使用变量代替)
4).组织测试数据并传参
7.6.代码
# 1.导包 unittest / parameterized
import unittest
from parameterized import parameterized
# 组织测试数据[(),(),()] or [[],[],[]]
data = [
(2,1),
(1,1),
(2,2)
]
# 2.定义测试类
class TestPa(unittest.TestCase):
# 3.书写测试方法（用到的测试数据使用变量代替）
@parameterized.expand(data)----> data可以由函数（读取json文件）返回
def test_pa(self,turenum,expect):
self.assertEqual(expect,turenum)
# 4.组织测试数据并传参(装饰器 @)八、跳过
8.1.作用
对于一些未完成的或者不满足测试条件的测试函数和测试类，可以跳过执行
8.2.格式
书写在TestCase文件中
8.3.使用
1).直接将测试函数标记成跳过@unittest.skip(跳过的原因”)
2).根据条件判断测试函数是否跳过，判断条件成立，跳过@unittest.skiplf(判断条件，跳过原因")
8.4.代码
import unittest
version = 29
class SkipTest(unittest.TestCase):
@unittest.skip('跳过原因')
def test_skip(self):
print('测试方法1')
@unittest.skipIf(version >= 30,'版本大于等于30')
def test_skip01(self):
print('测试方法2')
def test_skip02(self):
print('测试方法3')九、HTML报告
9.1.自带的测试报告
只有单独运行TestCase的代码，才会生成测试报告
9.2.生成第三方的测试报告
1).获取第三方的测试运行类模块，将其放在代码的目录中
2).导包unittest
3).使用套件对象，加载对象去添加用例方法
4).实例化使用第三方的运行对象并运行套件对象
9.3.代码
# 1.获取第三方的测试运行类模块，将其放在代码的目录中
from HTMLTestRunner import HTMLTestRunner
# 2.导包unittest
import unittest
# 3.使用套件对象，加载对象 去添加用例方法
suite = unittest.defaultTestLoader.discover('.','test_*.py')
# 4.实例化使用第三方的运行对象并运行套件对象
HTMLTestRunner()
# stream=sys.stdout,必填，测试报告的文件对象（open），注意点，要使用wb打开
# verbosity=1, 可选，报告的详细程度，默认1简略，2详细
# title=None, 可选，测试报告的标题
# description=None 可选，描述信息，python的版本，pycharm版本
file = 'report.html' #报告的后缀是.html
with open(file,'wb') as report:
runner = HTMLTestRunner(report) #运行对象
#运行对象执行套件,要写在with的缩进中
runner.run(suite)这里附上HTML的代码模块(适用于python3)
"""
A TestRunner for use with the Python unit testing framework. It
generates a HTML report to show the result at a glance.
The simplest way to use this is to invoke its main method. E.g.
import unittest
import HTMLTestRunner
... define your tests ...
if __name__ == '__main__':
HTMLTestRunner.main()
For more customization options, instantiates a HTMLTestRunner object.
HTMLTestRunner is a counterpart to unittest's TextTestRunner. E.g.
# output to a file
fp = file('my_report.html', 'wb')
runner = HTMLTestRunner.HTMLTestRunner(
stream=fp,
title='My unit test',
description='This demonstrates the report output by HTMLTestRunner.'
)
# Use an external stylesheet.
# See the Template_mixin class for more customizable options
runner.STYLESHEET_TMPL = '<link rel="stylesheet" href="my_stylesheet.css" type="text/css">'
# run the test
runner.run(my_test_suite)
------------------------------------------------------------------------
Copyright (c) 2004-2007, Wai Yip Tung
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name Wai Yip Tung nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
# URL: http://tungwaiyip.info/software/HTMLTestRunner.html
__author__ = "Wai Yip Tung"
__version__ = "0.8.2"
"""
Change History
Version 0.8.2
* Show output inline instead of popup window (Viorel Lupu).
Version in 0.8.1
* Validated XHTML (Wolfgang Borgert).
* Added description of test classes and test cases.
Version in 0.8.0
* Define Template_mixin class for customization.
* Workaround a IE 6 bug that it does not treat <script> block as CDATA.
Version in 0.7.1
* Back port to Python 2.3 (Frank Horowitz).
* Fix missing scroll bars in detail log (Podi).
"""
# TODO: color stderr
# TODO: simplify javascript using ,ore than 1 class in the class attribute?
import datetime
import io
import sys
import time
import unittest
from xml.sax import saxutils
# ------------------------------------------------------------------------
# The redirectors below are used to capture output during testing. Output
# sent to sys.stdout and sys.stderr are automatically captured. However
# in some cases sys.stdout is already cached before HTMLTestRunner is
# invoked (e.g. calling logging.basicConfig). In order to capture those
# output, use the redirectors for the cached stream.
#
# e.g.
# >>> logging.basicConfig(stream=HTMLTestRunner.stdout_redirector)
# >>>
class OutputRedirector(object):
""" Wrapper to redirect stdout or stderr """
def __init__(self, fp):
self.fp = fp
def write(self, s):
self.fp.write(s)
def writelines(self, lines):
self.fp.writelines(lines)
def flush(self):
self.fp.flush()
stdout_redirector = OutputRedirector(sys.stdout)
stderr_redirector = OutputRedirector(sys.stderr)
# ----------------------------------------------------------------------
# Template
class Template_mixin(object):
"""
Define a HTML template for report customerization and generation.
Overall structure of an HTML report
HTML
+------------------------+
|<html> |
| <head> |
| |
| STYLESHEET |
| +----------------+ |
| | | |
| +----------------+ |
| |
| </head> |
| |
| <body> |
| |
| HEADING |
| +----------------+ |
| | | |
| +----------------+ |
| |
| REPORT |
| +----------------+ |
| | | |
| +----------------+ |
| |
| ENDING |
| +----------------+ |
| | | |
| +----------------+ |
| |
| </body> |
|</html> |
+------------------------+
"""
STATUS = {
0: 'pass',
1: 'fail',
2: 'error',
}
DEFAULT_TITLE = 'Unit Test Report'
DEFAULT_DESCRIPTION = ''
# ------------------------------------------------------------------------
# HTML Template
HTML_TMPL = r"""<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>%(title)s</title>
<meta name="generator" content="%(generator)s"/>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
%(stylesheet)s
</head>
<body>
<script language="javascript" type="text/javascript"><!--
output_list = Array();
/* level - 0:Summary; 1:Failed; 2:All */
function showCase(level) {
trs = document.getElementsByTagName("tr");
for (var i = 0; i < trs.length; i++) {
tr = trs[i];
id = tr.id;
if (id.substr(0,2) == 'ft') {
if (level < 1) {
tr.className = 'hiddenRow';
}
else {
tr.className = '';
}
}
if (id.substr(0,2) == 'pt') {
if (level > 1) {
tr.className = '';
}
else {
tr.className = 'hiddenRow';
}
}
}
}
function showClassDetail(cid, count) {
var id_list = Array(count);
var toHide = 1;
for (var i = 0; i < count; i++) {
tid0 = 't' + cid.substr(1) + '.' + (i+1);
tid = 'f' + tid0;
tr = document.getElementById(tid);
if (!tr) {
tid = 'p' + tid0;
tr = document.getElementById(tid);
}
id_list[i] = tid;
if (tr.className) {
toHide = 0;
}
}
for (var i = 0; i < count; i++) {
tid = id_list[i];
if (toHide) {
document.getElementById('div_'+tid).style.display = 'none'
document.getElementById(tid).className = 'hiddenRow';
}
else {
document.getElementById(tid).className = '';
}
}
}
function showTestDetail(div_id){
var details_div = document.getElementById(div_id)
var displayState = details_div.style.display
// alert(displayState)
if (displayState != 'block' ) {
displayState = 'block'
details_div.style.display = 'block'
}
else {
details_div.style.display = 'none'
}
}
function html_escape(s) {
s = s.replace(/&/g,'&');
s = s.replace(/</g,'<');
s = s.replace(/>/g,'>');
return s;
}
/* obsoleted by detail in <div>
function showOutput(id, name) {
var w = window.open("", //url
name,
"resizable,scrollbars,status,width=800,height=450");
d = w.document;
d.write("<pre>");
d.write(html_escape(output_list[id]));
d.write("\n");
d.write("<a href='javascript:window.close()'>close</a>\n");
d.write("</pre>\n");
d.close();
}
*/
--></script>
%(heading)s
%(report)s
%(ending)s
</body>
</html>
"""
# variables: (title, generator, stylesheet, heading, report, ending)
# ------------------------------------------------------------------------
# Stylesheet
#
# alternatively use a <link> for external style sheet, e.g.
# <link rel="stylesheet" href="$url" type="text/css">
STYLESHEET_TMPL = """
<style type="text/css" media="screen">
body { font-family: verdana, arial, helvetica, sans-serif; font-size: 80%; }
table { font-size: 100%; }
pre { }
/* -- heading ---------------------------------------------------------------------- */
h1 {
font-size: 16pt;
color: gray;
}
.heading {
margin-top: 0ex;
margin-bottom: 1ex;
}
.heading .attribute {
margin-top: 1ex;
margin-bottom: 0;
}
.heading .description {
margin-top: 4ex;
margin-bottom: 6ex;
}
/* -- css div popup ------------------------------------------------------------------------ */
a.popup_link {
}
a.popup_link:hover {
color: red;
}
.popup_window {
display: none;
position: relative;
left: 0px;
top: 0px;
/*border: solid #627173 1px; */
padding: 10px;
background-color: #E6E6D6;
font-family: "Lucida Console", "Courier New", Courier, monospace;
text-align: left;
font-size: 8pt;
width: 500px;
}
}
/* -- report ------------------------------------------------------------------------ */
#show_detail_line {
margin-top: 3ex;
margin-bottom: 1ex;
}
#result_table {
width: 80%;
border-collapse: collapse;
border: 1px solid #777;
}
#header_row {
font-weight: bold;
color: white;
background-color: #777;
}
#result_table td {
border: 1px solid #777;
padding: 2px;
}
#total_row { font-weight: bold; }
.passClass { background-color: #6c6; }
.failClass { background-color: #c60; }
.errorClass { background-color: #c00; }
.passCase { color: #6c6; }
.failCase { color: #c60; font-weight: bold; }
.errorCase { color: #c00; font-weight: bold; }
.hiddenRow { display: none; }
.testcase { margin-left: 2em; }
/* -- ending ---------------------------------------------------------------------- */
#ending {
}
</style>
"""
# ------------------------------------------------------------------------
# Heading
#
HEADING_TMPL = """<div class='heading'>
<h1>%(title)s</h1>
%(parameters)s
<p class='description'>%(description)s</p>
</div>
""" # variables: (title, parameters, description)
HEADING_ATTRIBUTE_TMPL = """<p class='attribute'><strong>%(name)s:</strong> %(value)s</p>
""" # variables: (name, value)
# ------------------------------------------------------------------------
# Report
#
REPORT_TMPL = """
<p id='show_detail_line'>Show
<a href='javascript:showCase(0)'>Summary</a>
<a href='javascript:showCase(1)'>Failed</a>
<a href='javascript:showCase(2)'>All</a>
</p>
<table id='result_table'>
<colgroup>
<col align='left' />
<col align='right' />
<col align='right' />
<col align='right' />
<col align='right' />
<col align='right' />
</colgroup>
<tr id='header_row'>
<td>Test Group/Test case</td>
<td>Count</td>
<td>Pass</td>
<td>Fail</td>
<td>Error</td>
<td>View</td>
</tr>
%(test_list)s
<tr id='total_row'>
<td>Total</td>
<td>%(count)s</td>
<td>%(Pass)s</td>
<td>%(fail)s</td>
<td>%(error)s</td>
<td> </td>
</tr>
</table>
""" # variables: (test_list, count, Pass, fail, error)
REPORT_CLASS_TMPL = r"""
<tr class='%(style)s'>
<td>%(desc)s</td>
<td>%(count)s</td>
<td>%(Pass)s</td>
<td>%(fail)s</td>
<td>%(error)s</td>
<td><a href="javascript:showClassDetail('%(cid)s',%(count)s)">Detail</a></td>
</tr>
""" # variables: (style, desc, count, Pass, fail, error, cid)
REPORT_TEST_WITH_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
<td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
<td colspan='5' align='center'>
<!--css div popup start-->
<a class="popup_link" οnfοcus='this.blur();' href="javascript:showTestDetail('div_%(tid)s')" >
%(status)s</a>
<div id='div_%(tid)s' class="popup_window">
<div style='text-align: right; color:red;cursor:pointer'>
<a οnfοcus='this.blur();' οnclick="document.getElementById('div_%(tid)s').style.display = 'none' " >
[x]</a>
</div>
<pre>
%(script)s
</pre>
</div>
<!--css div popup end-->
</td>
</tr>
""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_NO_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
<td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
<td colspan='5' align='center'>%(status)s</td>
</tr>
""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_OUTPUT_TMPL = r"""
%(id)s: %(output)s
""" # variables: (id, output)
# ------------------------------------------------------------------------
# ENDING
#
ENDING_TMPL = """<div id='ending'> </div>"""
# -------------------- The end of the Template class -------------------
TestResult = unittest.TestResult
class _TestResult(TestResult):
# note: _TestResult is a pure representation of results.
# It lacks the output and reporting ability compares to unittest._TextTestResult.
def __init__(self, verbosity=1):
TestResult.__init__(self)
self.stdout0 = None
self.stderr0 = None
self.success_count = 0
self.failure_count = 0
self.error_count = 0
self.verbosity = verbosity
# result is a list of result in 4 tuple
# (
# result code (0: success; 1: fail; 2: error),
# TestCase object,
# Test output (byte string),
# stack trace,
# )
self.result = []
def startTest(self, test):
TestResult.startTest(self, test)
# just one buffer for both stdout and stderr
self.outputBuffer = io.StringIO()
stdout_redirector.fp = self.outputBuffer
stderr_redirector.fp = self.outputBuffer
self.stdout0 = sys.stdout
self.stderr0 = sys.stderr
sys.stdout = stdout_redirector
sys.stderr = stderr_redirector
def complete_output(self):
"""
Disconnect output redirection and return buffer.
Safe to call multiple times.
"""
if self.stdout0:
sys.stdout = self.stdout0
sys.stderr = self.stderr0
self.stdout0 = None
self.stderr0 = None
return self.outputBuffer.getvalue()
def stopTest(self, test):
# Usually one of addSuccess, addError or addFailure would have been called.
# But there are some path in unittest that would bypass this.
# We must disconnect stdout in stopTest(), which is guaranteed to be called.
self.complete_output()
def addSuccess(self, test):
self.success_count += 1
TestResult.addSuccess(self, test)
output = self.complete_output()
self.result.append((0, test, output, ''))
if self.verbosity > 1:
sys.stderr.write('ok ')
sys.stderr.write(str(test))
sys.stderr.write('\n')
else:
sys.stderr.write('.')
def addError(self, test, err):
self.error_count += 1
TestResult.addError(self, test, err)
_, _exc_str = self.errors[-1]
output = self.complete_output()
self.result.append((2, test, output, _exc_str))
if self.verbosity > 1:
sys.stderr.write('E ')
sys.stderr.write(str(test))
sys.stderr.write('\n')
else:
sys.stderr.write('E')
def addFailure(self, test, err):
self.failure_count += 1
TestResult.addFailure(self, test, err)
_, _exc_str = self.failures[-1]
output = self.complete_output()
self.result.append((1, test, output, _exc_str))
if self.verbosity > 1:
sys.stderr.write('F ')
sys.stderr.write(str(test))
sys.stderr.write('\n')
else:
sys.stderr.write('F')
class HTMLTestRunner(Template_mixin):
"""
"""
def __init__(self, stream=sys.stdout, verbosity=1, title=None, description=None):
self.stream = stream
self.verbosity = verbosity
if title is None:
self.title = self.DEFAULT_TITLE
else:
self.title = title
if description is None:
self.description = self.DEFAULT_DESCRIPTION
else:
self.description = description
self.startTime = datetime.datetime.now()
def run(self, test):
"Run the given test case or test suite."
result = _TestResult(self.verbosity)
test(result)
self.stopTime = datetime.datetime.now()
self.generateReport(test, result)
print(sys.stderr, 'Time Elapsed: %s' % (self.stopTime-self.startTime))
return result
def sortResult(self, result_list):
# unittest does not seems to run in any particular order.
# Here at least we want to group them together by class.
rmap = {}
classes = []
for n,t,o,e in result_list:
cls = t.__class__
if not cls in rmap:
rmap[cls] = []
classes.append(cls)
rmap[cls].append((n,t,o,e))
r = [(cls, rmap[cls]) for cls in classes]
return r
def getReportAttributes(self, result):
"""
Return report attributes as a list of (name, value).
Override this to add custom attributes.
"""
startTime = str(self.startTime)[:19]
duration = str(self.stopTime - self.startTime)
status = []
if result.success_count: status.append('Pass %s' % result.success_count)
if result.failure_count: status.append('Failure %s' % result.failure_count)
if result.error_count: status.append('Error %s' % result.error_count )
if status:
status = ' '.join(status)
else:
status = 'none'
return [
('Start Time', startTime),
('Duration', duration),
('Status', status),
]
def generateReport(self, test, result):
report_attrs = self.getReportAttributes(result)
generator = 'HTMLTestRunner %s' % __version__
stylesheet = self._generate_stylesheet()
heading = self._generate_heading(report_attrs)
report = self._generate_report(result)
ending = self._generate_ending()
output = self.HTML_TMPL % dict(
title = saxutils.escape(self.title),
generator = generator,
stylesheet = stylesheet,
heading = heading,
report = report,
ending = ending,
)
self.stream.write(output.encode('utf8'))
def _generate_stylesheet(self):
return self.STYLESHEET_TMPL
def _generate_heading(self, report_attrs):
a_lines = []
for name, value in report_attrs:
line = self.HEADING_ATTRIBUTE_TMPL % dict(
name = saxutils.escape(name),
value = saxutils.escape(value),
)
a_lines.append(line)
heading = self.HEADING_TMPL % dict(
title = saxutils.escape(self.title),
parameters = ''.join(a_lines),
description = saxutils.escape(self.description),
)
return heading
def _generate_report(self, result):
rows = []
sortedResult = self.sortResult(result.result)
for cid, (cls, cls_results) in enumerate(sortedResult):
# subtotal for a class
np = nf = ne = 0
for n,t,o,e in cls_results:
if n == 0: np += 1
elif n == 1: nf += 1
else: ne += 1
# format class description
if cls.__module__ == "__main__":
name = cls.__name__
else:
name = "%s.%s" % (cls.__module__, cls.__name__)
doc = cls.__doc__ and cls.__doc__.split("\n")[0] or ""
desc = doc and '%s: %s' % (name, doc) or name
row = self.REPORT_CLASS_TMPL % dict(
style = ne > 0 and 'errorClass' or nf > 0 and 'failClass' or 'passClass',
desc = desc,
count = np+nf+ne,
Pass = np,
fail = nf,
error = ne,
cid = 'c%s' % (cid+1),
)
rows.append(row)
for tid, (n,t,o,e) in enumerate(cls_results):
self._generate_report_test(rows, cid, tid, n, t, o, e)
report = self.REPORT_TMPL % dict(
test_list = ''.join(rows),
count = str(result.success_count+result.failure_count+result.error_count),
Pass = str(result.success_count),
fail = str(result.failure_count),
error = str(result.error_count),
)
return report
def _generate_report_test(self, rows, cid, tid, n, t, o, e):
# e.g. 'pt1.1', 'ft1.1', etc
has_output = bool(o or e)
tid = (n == 0 and 'p' or 'f') + 't%s.%s' % (cid+1,tid+1)
name = t.id().split('.')[-1]
doc = t.shortDescription() or ""
desc = doc and ('%s: %s' % (name, doc)) or name
tmpl = has_output and self.REPORT_TEST_WITH_OUTPUT_TMPL or self.REPORT_TEST_NO_OUTPUT_TMPL
# o and e should be byte string because they are collected from stdout and stderr?
if isinstance(o,str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# uo = unicode(o.encode('string_escape'))
uo = e
else:
uo = o
if isinstance(e,str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# ue = unicode(e.encode('string_escape'))
ue = e
else:
ue = e
script = self.REPORT_TEST_OUTPUT_TMPL % dict(
id = tid,
output = saxutils.escape(uo+ue),
)
row = tmpl % dict(
tid = tid,
Class = (n == 0 and 'hiddenRow' or 'none'),
style = n == 2 and 'errorCase' or (n == 1 and 'failCase' or 'none'),
desc = desc,
script = script,
status = self.STATUS[n],
)
rows.append(row)
if not has_output:
return
def _generate_ending(self):
return self.ENDING_TMPL
##############################################################################
# Facilities for running tests from the command line
##############################################################################
# Note: Reuse unittest.TestProgram to launch test. In the future we may
# build our own launcher to support more specific command line
# parameters like test title, CSS, etc.
class TestProgram(unittest.TestProgram):
"""
A variation of the unittest.TestProgram. Please refer to the base
class for command line parameters.
"""
def runTests(self):
# Pick HTMLTestRunner as the default test runner.
# base class's testRunner parameter is not useful because it means
# we have to instantiate HTMLTestRunner before we know self.verbosity.
if self.testRunner is None:
self.testRunner = HTMLTestRunner(verbosity=self.verbosity)
unittest.TestProgram.runTests(self)
main = TestProgram
##############################################################################
# Executing this module from the command line
##############################################################################
if __name__ == "__main__":
main(module=None)
9.4.流程总结
1).组织用例文件(TestCase里边)，书写参数化，书写断言，书写Fixture，书写跳过，如果单个测试文件，直接运行，得到测试报告，如果有多个测试文件，需要组装运行生成测试报告
2).使用套件对象组装，或者使用加载对象组装
3).运行对象运行
3.1).运行对象=第三方的运行类(文件对象(打开文件需要使用wb方式))
3.2).运行对象.run(套件对象）
十、今日学习思维导图
966
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
