web自动化测试框架

所谓框架，就是一种思想，一种整合的思想，就是将所做的事情的各个部分整合到一起构成一个框架。

使用selenium构建web自动化测试框架的流程

在项目中添加7个包：browserdriver、config、business、test_data、test_case、test_report、test_run

browserdriver包

browserdriver包：专门用来存放游览器驱动

config包

config包：存放配置文件，config.ini、read_ini.py、fw_driver.py、fw_findelement.py
config.ini:配置url和browser驱动
read_ini.py:用来读取config.ini的文件
fw_driver.py:用来调用驱动，进行一些初始化的操作，如打开游览器，使页面最大化等
fw_findelement.py:封装了各种基本元素定位方式的一个框架

config.ini

[fwconfig]
url=http://localhost/upload/forum.php
browser=chrome

read_ini.py

import configparser
import os
#获取项目路径
# print(os.path.dirname(os.path.dirname(__file__)))
class fwReadIni():
#初始化 路径
    # 参数1 file_name文件名指定文件名：例如config.ini就是文件名
    # 参数2  node 指定所需要节点名：例如config.ini里的jwconfig就是节点名
    #如果我没有传递文件和节点，那么就使用config.ini和jwconfig，如果传递了就使用传递过来的
    def __init__(self,file_name=None,node=None):
        self.file_name=file_name
        self.node=node
        if file_name==None:
            #文件名 加r 防止自动转义
            # os.path.dirname()用来获取文件的当前路径（即config包），套两层用来获取上一层路径，即项目路径
            self.file_name=os.path.dirname(os.path.dirname(__file__))+"\config\config.ini"
        if node==None:
            self.node = "fwconfig"
        self.cf=self.load_ini(self.file_name) #获取文件节点内容做解析

#加载配置文件
    def load_ini(self,file_name):
        #获取解析配置对象
        cf=configparser.ConfigParser()
        cf.read(file_name, encoding='utf-8')
        return  cf
#获取配置文件中的内容===>指定key，获取值
    def get_value(self,key):
        return  self.cf.get(self.node,key)

#进行单元测试，验证上述代码的作用
if __name__=='__main__':
    aa=fwReadIni()
    #也可以写成以下这种形式，使用传递过去的文件和节点而不是默认的
    # aa=jwReadIni(r"C:\Users\dinghan\PycharmProjects\dh0212\config\config.ini",'jwconfig')
    print(aa.get_value("browser")) #验证能否读取到配置文件中的内容

fw_driver.py

import os
from time import sleep

from selenium import webdriver

from config.read_ini import fwReadIni

#获取项目/工程路径
parent_path=os.path.dirname(os.path.dirname(__file__))
#读取配置文件对象
fw=fwReadIni()
#获取被测试网址
url=fw.get_value("url")
#获取火狐驱动
def get_firefox_driver():
    driver_path=parent_path+"/browserdriver/geckodriver"
    driver=webdriver.Firefox(executable_path=driver_path)
    driver.get(url)
    driver.maximize_window()
    driver.implicitly_wait(3)
    sleep(3)
    return  driver
#获取谷歌驱动
def get_chrome_driver():
    driver_path = parent_path + "/browserdriver/chromedriver"
    driver=webdriver.Chrome(executable_path=driver_path)
    driver.implicitly_wait(3)
    driver.get(url)
    driver.maximize_window()
    sleep(3)
    return   driver
#进行单元测试
if __name__=='__main__':
    # get_chrome_driver()
    get_firefox_driver()

fw_findelement.py

import os
from time import sleep

from config.fw_driver import get_chrome_driver
from config.read_ini import fwReadIni

#封装各种定位方式，精简代码量
#这个类在构造对象的时候要求有驱动（后面元素定位的时候要用到），
class fwFindElement():
    def __init__(self,driver):
        self.driver=driver
#获取元素
    def get_element(self,file=None,node=None,key=None):
        #读LocalElement.ini配置文件
        if file==None:
            file=os.path.dirname(os.path.dirname(__file__))+"/business/LocalElement.ini"

        if node==None:
            node="fwlogin_fatie"
        read_ini=fwReadIni(file,node)
        data=read_ini.get_value(key)
        #根据键得到值，分析值：
        #得出定位方式 文件中是以  > 方式切割
        by=data.split('>')[0]
        value=data.split('>')[1]
        try:
            if by=='id':#如果分析给的时id，则做id定位
                return self.driver.find_element_by_id(value)
            elif  by=='name':
                return self.driver.find_element_by_name(value)
            elif by=='className':
                return self.driver.find_element_by_class_name(value)
            elif by=='link_text':
                return self.driver.find_element_by_link_text(value)
            elif by=='xpath':
                return self.driver.find_element_by_xpath(value)
        except:
            return None



if __name__=="__main__":
    # 获取驱动
    driver=get_chrome_driver()
    #将驱动作为参数传给jwFindElement()类做初始化
    aa=fwFindElement(driver)
     #验证是否可以找到默认板块链接
    # print(aa.get_element(parent_path+"/business/LocalElement.ini","fwlogin_fatie","morenbankuai"))
    print(aa.get_element(key= "morenbankuai"))

business包

business包：业务包，存放业务的配置和流程，LocalElement.ini、fatie_business.py
LocalElement.ini：配置了业务中使用的定位方式所需要的id或name等属性确切的值
fatie_business.py：业务流程的代码

LocalElement.ini

#应用po思想将常用的元素和操作封装起来
#发帖子的常用功能
# 页面元素修改后  只要修改配置文件即可
[fwlogin_fatie]
user_name=id>ls_username
user_password=id>ls_password
login_button=xpath>//*[@id="lsform"]/div/div/table/tbody/tr[2]/td[3]/button/em
luntan=link_text>论坛
#注意这里只能用xpath定位别的方式定位不了
morenbankuai=xpath>//*[@id="category_1"]/table/tbody/tr[1]/td[2]/h2/a
tiezi_title=id>subject
tiezi_content=id>fastpostmessage
tiezi_button=xpath>//*[@id="fastpostsubmit"]/strong
#找回复按钮用于验证发帖成功的元素
fatie_success=xpath>//*[@id="post_reply"]/img

fatie_business.py

#前置读取
from time import sleep
from config.fw_driver import get_chrome_driver, get_firefox_driver
from config.fw_findelement import fwFindElement
from config.read_ini import fwReadIni

fw=fwReadIni()
def  fw_fatie(username,password,tiezi_title,tiezi_content):
    #1.判断使用chrome还是火狐
    driver=None
    if fw.get_value("browser")=="chrome":
        driver=get_chrome_driver()
    else:
        driver=get_firefox_driver()
    #专门查找元素
    fw2=fwFindElement(driver)
    try:
        #先登录
        #用户名
        fw2.get_element(key="user_name").send_keys(username)
        #密码
        fw2.get_element(key="user_password").send_keys(password)
        #点击登录
        fw2.get_element(key="login_button").click()
        sleep(2)
        #点击论坛
        fw2.get_element(key="luntan").click()
        sleep(2)
        #点击默认板块
        fw2.get_element(key="morenbankuai").click()
        sleep(2)
        #发帖
        fw2.get_element(key="tiezi_title").send_keys(tiezi_title)
        fw2.get_element(key="tiezi_content").send_keys(tiezi_content)
        fw2.get_element(key="tiezi_button").click()
        #查找 回复 图片是否存在：存在，返回True；不存在，返回False
        result=fw2.get_element(key="fatie_success")
        # print("找回复图片的结果是",result)
        if  result==None:
            return False
        else:
            return True
    except Exception as e:
        print("fw say:",e)
        #发帖子过程出异常
        return False
    finally:
        sleep(2)
        driver.quit()
if __name__=="__main__":
    #预期发帖成功
    fw_fatie("admin","123456","今天真高兴~","aaaa")
    # fw_fatie("admin", "123456", "今天真高兴~", "")

test_data包

test_data包：存放测试数据的包，login_fatie.csv、fwtestdata.py
login_fatie.csv:存放测试用例数据的csv文件
fwtestdata.py:用来读取csv文件中数据的文件

login_fatie.csv

admin,123456,今天真高兴,111
admin,123456,,content
admin,123456,title,

fwtestdata.py

import csv

# 设计函数专门读取 csv文件
def get_csv_data(csv_file,line):#文件名和行号
        fw_csv_file= open(csv_file, 'r', encoding='utf-8-sig') #打开CSV文件
        reader = csv.reader(fw_csv_file)#读取
        # 参数2 :决定了下标位置的开始计数方式
        for index, row in enumerate(reader, 1):#循环遍历CSV文件里的每一行，index代表行的编号，row代表行的值
            if index == line:
                print(row)
                return row

if __name__=="__main__":
    get_csv_data("./login_fatie.csv",1)
    get_csv_data("./login_fatie.csv", 2)
    get_csv_data("./login_fatie.csv", 3)

test_case包

test_case包：存放测试用例的包,test_fatie.py
test_fatie.py:使用unitest框架，将测试用例放入其中

test_fatie.py

import os
import unittest
import warnings

from business.fatie_business import fw_fatie
from test_data.fwtestdata import get_csv_data

class TestLogin(unittest.TestCase):
    #获取项目路径
    csv_file = os.path.abspath(os.path.dirname(os.getcwd())) + "\\test_data\\login_fatie.csv"
    def setUp(self):
        print("开始测试~")
        # 这句话的作用是用来忽略 ResourceWaring 异常警告的
        warnings.simplefilter("ignore", ResourceWarning)


    def tearDown(self):
        print("结束测试~")


    def test_fatie_111(self):
        print("第一条用例测试~")
        data = get_csv_data(self.csv_file, 1)#获取csv文件中的第一行数据
        # 预期失败用例（获取第一列和第二列数据）交给 登录
        self.assertTrue(fw_fatie(data[0], data[1],data[2],data[3]))


    def test_fatie_222(self):#获取csv文件中的第二行数据
        print("第二条用例测试~")
        data = get_csv_data(self.csv_file, 2)
        # 预期失败用例
        self.assertFalse(fw_fatie(data[0], data[1],data[2],data[3]))


    def test_fatie_333(self):
        print("第三条用例测试~")#获取csv文件中的第三行数据
        data = get_csv_data(self.csv_file, 3)
        # 预期失败用例
        self.assertFalse(fw_fatie(data[0], data[1],data[2],data[3]))


if __name__ == '__main__':
    unittest.main()

test_report包

test_report包：存放测试报告

test_run包

test_run包：BSTestRunner.py、fwrun.py
BSTestRunner.py:一个第三方包，用来生成html测试报告
fwrun.py:添加测试用例并执行生成测试报告

BSTestRunner.py

"""
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 BSTestRunner

    ... define your tests ...

    if __name__ == '__main__':
        BSTestRunner.main()


For more customization options, instantiates a BSTestRunner object.
BSTestRunner is a counterpart to unittest's TextTestRunner. E.g.

    # output to a file
    fp = file('my_report.html', 'wb')
    runner = BSTestRunner.BSTestRunner(
                stream=fp,
                title='My unit test',
                description='This demonstrates the report output by BSTestRunner.'
                )

    # 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
Copyright (c) 2016, Eason Han
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.
"""

__author__ = "Wai Yip Tung && Eason Han"
__version__ = "0.8.4"


"""
Change History

Version 0.8.3
* Modify html style using bootstrap3.

Version 0.8.3
* Prevent crash on class or module-level exceptions (Darren Wurf).

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 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 BSTestRunner 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=BSTestRunner.stdout_redirector)
#   >>>

def to_unicode(s):
    try:
        return str(s)
    except UnicodeDecodeError:
        # s is non ascii byte string
        return s.decode('unicode_escape')

class OutputRedirector(object):
    """ Wrapper to redirect stdout or stderr """
    def __init__(self, fp):
        self.fp = fp

    def write(self, s):
        self.fp.write(to_unicode(s))

    def writelines(self, lines):
        lines = map(to_unicode, 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"""<!DOCTYPE html>
<html lang="zh-cn">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <title>%(title)s</title>
    <meta name="generator" content="%(generator)s"/>
    <link rel="stylesheet" href="http://cdn.bootcss.com/bootstrap/3.3.0/css/bootstrap.min.css">
    %(stylesheet)s

    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
      <script src="http://cdn.bootcss.com/html5shiv/3.7.2/html5shiv.min.js"></script>
      <script src="http://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
  </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,'&amp;');
    s = s.replace(/</g,'&lt;');
    s = s.replace(/>/g,'&gt;');
    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>

<div class="container">
    %(heading)s
    %(report)s
    %(ending)s
</div>

</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">

/* -- css div popup ------------------------------------------------------------------------ */
.popup_window {
    display: none;
    position: relative;
    left: 0px;
    top: 0px;
    /*border: solid #627173 1px; */
    padding: 10px;
    background-color: #99CCFF;
    font-family: "Lucida Console", "Courier New", Courier, monospace;
    text-align: left;
    font-size: 10pt;
    width: 500px;
}

/* -- report ------------------------------------------------------------------------ */

#show_detail_line .label {
    font-size: 85%;
    cursor: pointer;
}

#show_detail_line {
    margin: 2em auto 1em auto;
}

#total_row  { font-weight: bold; }
.hiddenRow  { display: none; }
.testcase   { margin-left: 2em; }

</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><strong>%(name)s:</strong> %(value)s</p>
""" # variables: (name, value)



    # ------------------------------------------------------------------------
    # Report
    #

    REPORT_TMPL = """
<p id='show_detail_line'>
<span class="label label-primary" οnclick="showCase(0)">Summary</span>
<span class="label label-danger" οnclick="showCase(1)">Failed</span>
<span class="label label-default" οnclick="showCase(2)">All</span>
</p>
<table id='result_table' class="table">
    <thead>
        <tr id='header_row'>
            <th>Test Group/Test case</td>
            <th>Count</td>
            <th>Pass</td>
            <th>Fail</td>
            <th>Error</td>
            <th>View</td>
        </tr>
    </thead>
    <tbody>
        %(test_list)s
    </tbody>
    <tfoot>
        <tr id='total_row'>
            <td>Total</td>
            <td>%(count)s</td>
            <td class="text text-success">%(Pass)s</td>
            <td class="text text-danger">%(fail)s</td>
            <td class="text text-warning">%(error)s</td>
            <td>&nbsp;</td>
        </tr>
    </tfoot>
</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 class="btn btn-xs btn-primary"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 btn btn-xs btn-default" ο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;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'>&nbsp;</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.outputBuffer = StringIO.StringIO()
        self.outputBuffer = io.StringIO()
        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
        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 BSTestRunner(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, '\nTime Elapsed: %s' % (self.stopTime-self.startTime)
        print(sys.stderr, '\nTime 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 rmap.has_key(cls):
            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('<span class="text text-success">Pass <strong>%s</strong></span>'    % result.success_count)
        if result.failure_count: status.append('<span class="text text-danger">Failure <strong>%s</strong></span>' % result.failure_count)
        if result.error_count:   status.append('<span class="text text-warning">Error <strong>%s</strong></span>'   % 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 = 'BSTestRunner %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),
                    name = name,
                    value = 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 'text text-warning' or nf > 0 and 'text text-danger' or 'text text-success',
                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 = o.decode('latin-1')
            uo = o
        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.decode('latin-1')
            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'),
            Class = (n == 0 and 'hiddenRow' or 'text text-success'),
            # style = n == 2 and 'errorCase' or (n == 1 and 'failCase' or 'none'),
            style = n == 2 and 'text text-warning' or (n == 1 and 'text text-danger' or 'text text-success'),
            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 BSTestRunner as the default test runner.
        # base class's testRunner parameter is not useful because it means
        # we have to instantiate BSTestRunner before we know self.verbosity.
        if self.testRunner is None:
            self.testRunner = BSTestRunner(verbosity=self.verbosity)
        unittest.TestProgram.runTests(self)

main = TestProgram

##############################################################################
# Executing this module from the command line
##############################################################################

if __name__ == "__main__":
    main(module=None)

fwrun.py

import sys
#声明包查找的路径（框架路径）
# path=r'C:\Users\Administrator\PycharmProjects\p2222'
# sys.path.append(path)

from test_run.BSTestRunner import BSTestRunner
import unittest
import time
#指定测试用例和测试报告的路径:当前目录的上一层目录下的test_case目录和test_report目录
test_dir = '../test_case'
report_dir = '../test_report'
#匹配测试多条用例
discover = unittest.defaultTestLoader.discover(test_dir, pattern='test_*.py')
#定义报告的文件格式
now = time.strftime("%Y-%m-%d-%H_%M_%S")
report_name = report_dir + '/' + now + 'test_report.html'
#运行用例并生成测试报告
with open(report_name, 'wb') as f:
    runner = BSTestRunner(stream=f, title="fw的发帖子测试报告", description="我的论坛网站测试报告")
    runner.run(discover)