Pythonの単体テストと拡張HTMLTestRunnerの詳細説明

unnitest は、Python の重要な単体テスト フレームワークです。Python で開発する同僚は、これを使用する必要はないかもしれません。十分です。ただし、自動テスターは unnitest の実行原理と関連モジュールの役割をよく理解しておく必要があると思います。以下にいくつかの簡単な要件について説明します。

1. unnitest 実行プロセスの使用方法: たとえば、selenium+unnitest を使用してプロセスを実行し、test2 ではログインの成功に基づいてクエリ テストを実装します。 test1 でいくつかのデータをクエリし、データを送信します。test1 でログインしてからブラウザを閉じ、再度クエリを実行してからログインします。これらの手順を 1 つのテストにまとめて作成することもできます。しかし、そのプロセスが複雑でわかりにくいと感じませんか? 2. 制御方法unnitest のテスト配列に格納される TestCase は、デフォルトでは最初の文字でソートされます。test1、test2...test9 の実行順序では問題ありませんが、test1、test2 などの複数のテストの場合は問題ありません。 .........test18、これは最も不完全ではありません。この順序に従って、test1、test10、....test18、test2、....を実行すると言いました。 ....test9. もちろん、私が言ったことはユニットに対するものです (後述するように、テスト間にデータの依存関係がない限り) が、プロセスに影響を与える可能性があります

3.プロセスのテストで特定のテストの実行をスキップするかどうか。たとえば、test1 でログインさえできなかったのに、その後のテストを実行する意味はありますか。報告されるエラーはすべて NouchElement エラーです。これらのエラーには意味がなく、純粋に時間の無駄です... 出てくるレポートも「人道的」ではありません。したがって、現時点での良いアイデアは、test1 が実行に失敗した場合です。実際、失敗するのは test1 だけではなく、test1、test2...testN のいずれかのテストが失敗した場合、後続のすべてのテストが動的にスキップされる可能性があります。もちろん、次のテストが前のテストと関係がない場合は、前のテストが成功したかどうかに関係なく、スキップしないことも選択できます。また、test1 ログインにのみ関連する場合もあります。ログインが成功している限り、スキップしません。ログインが失敗した場合は、スキップします。その他にもたくさんあります。重要なのは、それがレポートに表示されることです。ユースケースをスキップしたとすると、レポートにはそれが表示されません。このようにすると、上司はあなたが怠け者でユースケースをほとんど書かないと考えるでしょう。 前のユースケースが失敗したため表示されないのだと説明するにはまだ震える必要があります...

私たちの状況は次のようなものです、test1 は実行に失敗しました、test2... testN、レポートにはすべて次のことが示されています。ケースはスキップとしてマークされており、それをクリックする理由があります。「test1 が正常に実行されなかったため、このケースはスキップされました。」これが HTMLTestRunner を拡張した理由です。拡張方法は後で 1 行ずつ説明します。

......他にもたくさんあります

付け加えておきますが、なぜわざわざこのプロセスを行う必要があるのでしょうか? 会社にはモジュールが多すぎて複雑なため、単体テストの機会はあまり役に立ちません。各ビジネスのプロセスは問題ではありませんが、ユニテストの分析には影響しません。

アイデアはたくさんありますが、どうやって実装するのでしょうか?それでは、Python の unnitest を詳しく見てみましょう。

unnitest については、複雑に思えますが、unnitest=TestCase+TestResult として説明します。これら 2 つのモジュールに慣れていれば、「何でもできます」。 ！ TestSuite や TextTestRunner などのようなものは存在しないと言う人もいるかもしれません。確かに、これらのモジュールのほとんどを通常使用しているのは事実ですが、実際には、最終的に実行されるのは TestCase の run メソッドであり、結果は次のようになります。 TestResult (またはそのサブクラス) に与えられます。まず単純な単純な例を見て、それを拡張してみましょう。例は次のとおりです。

import unittest
class Mydemo(unittest.TestCase):
    def setUp(self):
        self.a=1
    def test1(self):
        print "i am test1 the value of a is {}".format(self.a)
    def test2(self):
        print "i am test2 the value of a is {}".format(self.a)
    def  test3(self):
        print "i am test3 the value of a is {}".format(self.a)
if __name__ == '__main__':
    unittest.main()

実行結果は次のとおりです。

i am test1 the value of a is 1
...
i am test2 the value of a is 1
i am test3 the value of a is 1
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

これで問題ありません。では、unnitest.main() が何であるかを考えてみます。他の書き方はありますか? test1、test2 だけを実行できますが、test3 は実行したくないですか (今のところスキップする必要はありません)。次に、unittest.main() から調べます。実際、デバッグ エントリは実際に TestProgram クラスを実行します。コードの

constructor

部分を投稿します。

if argv is None:
            argv = sys.argv#得到当前模块的绝对路径

        self.exit = exit
        self.failfast = failfast
        self.catchbreak = catchbreak
        self.verbosity = verbosity
        self.buffer = buffer
        self.defaultTest = defaultTest
        self.testRunner = testRunner
        self.testLoader = testLoader
        self.progName = os.path.basename(argv[0])
        self.parseArgs(argv)#查找当前module的Testsuite
        self.runTests()#执行测试

さて、上記のことから、実際には 2 つの主要なステップがあることがわかります: まず、テストするテストケースを見つけます。そしてそれを Testsuite に追加します。2 番目: Testsuite を実行し、結果を TestResult に渡します。

まず最初に、TestCase とは何かを理解してください。テストスイートとは何ですか? 2 番目: これらのテストケースまたはテストスイートを見つけるにはどうすればよいですか?

テストケースとは何ですか?

Test で始まる場合は TesetCase をテストケースと呼ぶという人もいますが、正確に言うと、次のような TesetCase クラスをインスタンス化する TestCase です。結果は次のとおりです:

...
i am Mytest1 the value of a is 1
----------------------------------------------------------------------
i am Mytest2 the value of a is 1
Ran 3 tests in 0.000s
i am Mytest3 the value of a is 1
 
OK

 上面3个Testcase可并没有以test开头...那么为什么大家都要默认以test开头来写呢，我们打开C:\Python27\Lib\unittest\loader.py这个模块在296行有写defaultTestLoader = TestLoader()，我们来看看TestLoader这个类第一行就看见testMethodPrefix = 'test'，也就是说如果你使用到defaultTestLoader，那么默认是以test开头的方法为一个用例，具体可以在TestLoader类中的getTestCaseNames得到实现,红字注释部分为什么testCaseClass要有call方法，我们后面提到。（不知道call这个魔法属性的用法自行百度）

def getTestCaseNames(self, testCaseClass):
        """Return a sorted sequence of method names found within testCaseClass
        """
        def isTestMethod(attrname, testCaseClass=testCaseClass,
                         prefix=self.testMethodPrefix):
            return attrname.startswith(prefix) and \
                hasattr(getattr(testCaseClass, attrname), '__call__')#返回一个testCaseClass有__call__方法且attrname以prefix开头的为一个testcase
        testFnNames = filter(isTestMethod, dir(testCaseClass))
        if self.sortTestMethodsUsing:
            testFnNames.sort(key=_CmpToKey(self.sortTestMethodsUsing))
        return testFnNames

原来是这样啊，我们上文提到的unittest.main()其实用的就是defaultTestLoader，当然你把if name == 'main'下面的代码换成unittest.main()肯定不成功，除非你把上文提到的testMethodPrefix 换成"Mytest"。有了对TestCase的看法，我们具体来看看这个类。

这个类里面包含了我们所能用的方法。我列出来一些主要的吧。

setUp（）在每个test执行前都要执行的方法。

tearDown()在每个test执行后都要执行的方法。（不管是否执行成功）

setUpClass()在一个测试类中在所有test开始之前，执行一次且必须使用到Testsuite(只有在TestSuite的run方法里面才对其调用)

tearDownClass()在一个测试类中在所有test结束之后，执行一次且必须使用到Testsuite(只有在TestSuite的run方法里面才对其调用)

run()这是unnitest的核心，逻辑也相对复杂，但是很好理解，具体自己看源码。所有最终case的执行都会归结到该run方法。

还有一个重要的_resultForDoCleanups私有变量，存储TestResult的执行结果，这个在构建后面的skip用到。

我们要明确TestCase类中所有的测试用例是独立的，我上面说过了，其实每个testcase就是一个个TestCase类的实例对象，所以不要企图在某个test存储或改变一个变量，下个test中能用到，除非利用到setUpClass。我们看个例子：

import unittest
class Mydemo(unittest.TestCase):
    def test1(self):
        self.a=1
        print "i am test1 the value of a is {}".format(self.a)
    def test2(self):
        print "i am test2 the value of a is {}".format(self.a)
if __name__ == '__main__':
    unittest.main()

 结果：

C:\Python27\python.exe D:/Moudle/module_1/test4.py
i am test1 the value of a is 1
.E
======================================================================
ERROR: test2 (__main__.Mydemo)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/Moudle/module_1/test4.py", line 7, in test2
    print "i am test2 the value of a is {}".format(self.a)
AttributeError: 'Mydemo' object has no attribute 'a'

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (errors=1)

上面就是说明TestCase类中所有的测试用例是独立的，每个testcase就是由TestCase实例化的一个独立的实例。那是不是就是每个TestCase不能共享数据呢？答案是否定的，不能共享的原因是我们上面用到的是self（实例对象属性），能共享我们就必须使用类属性，比如下个例子：

import unittest
class Mydemo(unittest.TestCase):
    def test1(self):        Mydemo.a=1
        print "i am test1 the value of a is {}".format(self.a)
    def test2(self):
        print "i am test2 the value of a is {}".format(Mydemo.a)
if name == 'main':
    unittest.main()

 运行结果如下：

i am test1 the value of a is 1
..
i am test2 the value of a is 1
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

 这些东西其实是python类的一些动态行为，但是既然和unnitest关联，就随便提下。我们运行test1的时候，给Mydemo加了一个新的属性a（值为1），当我们运行test2时，我们就能拿到Mydemo类的属性了。说了TaseCase我们不得不说下TestSuite。TestSuite是有一个个TestCase组成的，当然TestSuite里面可以再嵌套TestSuite。我们打开C:\Python27\Lib\unittest\suite.py找到TestSuite，它继承于BaseTestSuite，其实主要的一些属性就那么几个：

1.self._tests这个私有变量里面方的是所有的TestCase或者TestSuite。

2.run()方法，方法如下：

def run(self, result, debug=False):
        topLevel = False
        if getattr(result, '_testRunEntered', False) is False:
            result._testRunEntered = topLevel = True
 
        for test in self:#这个循环会一直遍历_tests中的变量
            if result.shouldStop:
                break
            if _isnotsuite(test):
                self._tearDownPreviousClass(test, result)
                self._handleModuleFixture(test, result)
                self._handleClassSetUp(test, result)#这一句提到了调用setUpClass的规则
                result._previousTestClass = test.__class__
 
                if (getattr(test.__class__, '_classSetupFailed', False) or
                    getattr(result, '_moduleSetUpFailed', False)):
                    continue
 
            if not debug:
                test(result)#如果是TestSuit继续调用该方法，如果是TestCase则调用TestCase中的run方法
            else:
                test.debug()
 
        if topLevel:
            self._tearDownPreviousClass(None, result)
            self._handleModuleTearDown(result)
            result._testRunEntered = False
        return result

 

 注释1：self是个迭代对象，一直遍历上文提到的self._tests变量

注释2：我们看看_handleClassSetUp中的方法，发现在在用例的执行过程中，每个TestCase类只会调用一次setUpClass方法，同理tearDownClass。对用这一点我们举个例子：

import unittest
class Mydemo(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print "I am setUpClass"
    def test1(self):
        print "i am test1 "
    def test2(self):
        print "i am test2"
    @classmethod
    def tearDownClass(cls):
        print "I am tearDownClass"
if __name__ == '__main__':
    unittest.main()

运行结果是：

C:\Python27\python.exe D:/Moudle/module_1/test4.py
I am setUpClass
..
i am test1 
----------------------------------------------------------------------
i am test2
Ran 2 tests in 0.001s
I am tearDownClass

OK

说明类方法setUpClass与tearDownClass只执行了一遍了，这就回答了我们第一个问题了：在setUpClass中启动浏览器，执行完所有流程后关闭浏览器，举一个简单的demo就是：

#coding=utf-
import unittest
from  selenium import webdriver
class Mydemo(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.browser=webdriver.Firefox()
    def test1(self):
        '''登录'''
        browser=self.browser
        #do someting about login
    def test2(self):
        '''查询'''
        browser = self.browser
        # do someting about search
    def test3(self):
        '''提交数据'''
        browser = self.browser
        # do someting about submmit
    @classmethod
    def tearDownClass(cls):
        browser=self.browser
        browser.close()
　　　　
if name == 'main':
    unittest.main()

 上面就会在所有的case执行之前启动firefox,因为每个test中拿到的都是Mydemo类中同一个webdriver对象，所以能保证操作的都是同一个浏览器句柄。关于这个setUpClass如果想要动态的改变某个值一定要使用python的可变的对象比如list,dict等...这些其实都是一些python类的一些知识,算我啰嗦吧我还是想举个例子，嫌烦的同学，绕过这一部分吧。

#coding=utf-8
import unittest
from  selenium import webdriver
class Mydemo(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.a=1
    def test1(self):
        print "before update the a in test1 is:{}".format(self.a)
        self.a=self.a+1
        print "after update the a in test1 is:{}".format(self.a)
    def test2(self):
        print "the value in test2 is:{}".format(self.a)
    @classmethod
    def tearDownClass(cls):
        print "I am tearDownClass"
if name == 'main':
    unittest.main()

 运行结果：

C:\Python27\python.exe D:/Moudle/module_1/test4.py
before update the a in test1 is:1
..
after update the a in test1 is:2
----------------------------------------------------------------------
the value in test2 is:1
I am tearDownClass
Ran 2 tests in 0.001s

OK

 我们想在test1中改变a的值，但是test2中的结果说明a没有被改变，这其实也很好理解。如果我们想要改变怎么办，看看下面的例子：

#coding=utf-8
import unittest
from  selenium import webdriver
class Mydemo(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.a=[0]
    def test1(self):
        print "before update the a in test1 is:{}".format(self.a[0])
        self.a[0]=self.a[0]+1
        print "after update the a in test1 is:{}".format(self.a[0])
    def test2(self):
        print "the value in test2 is:{}".format(self.a[0])
    @classmethod
    def tearDownClass(cls):
        print "I am tearDownClass"
if name == 'main':
    unittest.main()

 运行结果：

C:\Python27\python.exe D:/Moudle/module_1/test4.py
..
before update the a in test1 is:0
----------------------------------------------------------------------
after update the a in test1 is:1
Ran 2 tests in 0.000s
the value in test2 is:1

I am tearDownClass
OK

 我们把a变成一个list，发现a的值在test2中改变了。好了这一部分就这样了。

注释三：这个其实也是python类的一些知识可能有的人没有关注就是call这个魔法属性，我们看到在这个循环中test如果是testsuite对象，那么会调用中TestSuite类中的call方法（在其父类BaseTestSuite中），该方法中会再次调用run方法。一直到test是个testcase对象，那么就会调用我们上文提到的TestCase中的call（这就是我们上面提到为什么找有call属性类实例的方法），一样该call中的方法也是调用TestCase中的run。所以最终所有的执行其实都是执行TestCase中的run方法。

上面大致讲了一些TestCase与TestSuit的知识，可能穿插的比较多。

如何创建这些Testcase或者TestSuite？

1.自己手动实例化TestCase

这个上面已经有例子，与普通类无异，这中在自动化领域用处不大，我们不能一个个的实例化吧...

2.利用C:\Python27\Lib\unittest\loader.py模块的TestLoader，该类提供了多种不同情境find testcase。

1.loadTestsFromTestCase利用给出的TestCase类名称返回找到所有的suite。

2.loadTestsFromMoudle利用给出的Moudle返回找到所有的suite。

3.loadTestsFromName利用给出的Moudle名称返回找到所有的suite。

4.discover返回给定目录下符合pattern类型(默认test*.py)所有的suite。

其实这些方法最终都要归结到loadTestsFromTestCase，可能官方不提供我们也能写，既然有了就直接用吧。

经过上面的说明，我觉得大家对一TestCase，TestSuite应该有一个比较清楚的认识了，也解决了我自己的提问。问题一：我们可以用类方法setUpClass实现。对于问题二：我们可以利用TestLoader类中的方法返回suite，然后对这些suite按照自己的想法进行一些排序，然后再调用run方法。说完了TestCase我们再说下TestResult。

什么是TestResult？

顾名思义，testresult就是存储测试结果的，不过通过何种方式调用run函数，最终到Testcase中的run方法时必须传一个result（如果为None则自己实例化一个TestResult对象)。这个result就是TestResult对象或者是其子类的对象，我们每次执行的结果都会调用其addFailure，addSuccess，addSkip....等方法将执行结果保存到TestResult实例属性中。我们还是来看看TestCase的run方法：

def run(self, result=None):
        orig_result = result
        if result is None:#如果没有传入result对象自己实例化一个TestResult对象
            result = self.defaultTestResult()
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()
 
        self._resultForDoCleanups = result
        result.startTest(self)
 
        testMethod = getattr(self, self._testMethodName)
        if (getattr(self.__class__, "__unittest_skip__", False) or
            getattr(testMethod, "__unittest_skip__", False)):
            # If the class or method was skipped.
            try:
                skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
                            or getattr(testMethod, '__unittest_skip_why__', ''))
                self._addSkip(result, skip_why)#调用addSkip
            finally:
                result.stopTest(self)
            return
        try:
            success = False
            try:
                self.setUp()
            except SkipTest as e:
                self._addSkip(result, str(e))
            except KeyboardInterrupt:
                raise
            except:
                result.addError(self, sys.exc_info())#调用addError
            else:
                try:
                    testMethod()
                except KeyboardInterrupt:
                    raise
                except self.failureException:
                    result.addFailure(self, sys.exc_info())#调用addFailure
                except _ExpectedFailure as e:
                    addExpectedFailure = getattr(result, 'addExpectedFailure', None)
                    if addExpectedFailure is not None:
                        addExpectedFailure(self, e.exc_info)#调用addExpectedFailure
                    else:
                        warnings.warn("TestResult has no addExpectedFailure method, reporting as passes",
                                      RuntimeWarning)
                        result.addSuccess(self)#调用addSuccess
                except _UnexpectedSuccess:
                    addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None)
                    if addUnexpectedSuccess is not None:
                        addUnexpectedSuccess(self)
                    else:
                        warnings.warn("TestResult has no addUnexpectedSuccess method, reporting as failures",
                                      RuntimeWarning)
                        result.addFailure(self, sys.exc_info())
                except SkipTest as e:
                    self._addSkip(result, str(e))
                except:
                    result.addError(self, sys.exc_info())
                else:
                    success = True
 
                try:
                    self.tearDown()
                except KeyboardInterrupt:
                    raise
                except:
                    result.addError(self, sys.exc_info())
                    success = False
 
            cleanUpSuccess = self.doCleanups()
            success = success and cleanUpSuccess
            if success:
                result.addSuccess(self)
        finally:
            result.stopTest(self)
            if orig_result is None:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()

 通过注释部分我们可以看出，每次执行用例时，都会把执行结果保存到TestResult中。我们再看看TextTestRunner这个类，在开始就使用了类TextTestResult，而这个类也是继承TestResult，而后在执行的过程中最终把TextTestResult实例对象传递给TestCase的run方法。所以我上文说了，不过你是用什么方式执行unnitest,到最后都是TestCase的run方法与TestResult的游戏。而我们的HTMLTestRunner模块也是在继承在TestResult类的基础上的。

说完了TestCase我们来看看第三个问题吧，也是比较有实际意义的话题，开始我是这样跳过某些test的，代码是这样的：

#coding=utf-8
import unittest
a=[False]
class Mydemo(unittest.TestCase):
    def test1(self):
        try:
            print "i am test1"
            #test 1 do some thing
        except Exception,e:
            a[0] = True
            raise e
    @unittest.skipIf(a[0],"test1 fail skip test2")
    def test2(self):
        try:
            print "i am test2"
            raise  AssertionError("error")
            # test2 do some thing
        except Exception,e:
            a[0] = True
            raise e
    @unittest.skipIf(a[0], "test1 fail skip test2")
    def test3(self):
        try:
            print "i am test3"
            # test2 do some thing
        except Exception, e:
            a[0] =True
            raise e
if __name__ == '__main__':
    unittest.main()

 想法很简单：就是利用一个全局的数组，如果某个test执行出错我就更改这个数组元素，到下一个case执行的时候就会判断是否要跳过。上面因为test2出错了，原本我们想跳过test3，但是很遗憾并没有跳过test3！结果如下：

C:\Python27\python.exe D:/Moudle/module_1/test4.py
i am test1
.F.
i am test2
======================================================================
i am test3
FAIL: test2 (__main__.Mydemo)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/Moudle/module_1/test4.py", line 20, in test2
    raise e
AssertionError: error

----------------------------------------------------------------------
Ran 3 tests in 0.000s

FAILED (failures=1)

原因很简单：python在创建Mydemo这个类的时候，由于实例方法都使用了装饰器unittest.skipIf，所以每个方法都向unittest.skipIf这个装饰传递传递参数a[0]，但是这个a[0]是没用执行过任何case之前的a[0],也就是我们刚开始定义的a[0]=Flase，所以不可能跳过的。退一万步讲，即使这样可行，也太不美观了吧。我们想的是当执行当前的test时能判断前面是否有出错的case，有的话就跳过了。可行吗?我觉得可行。主要就是用到我上面提到的TestCase中的_resultForDoCleanups的变量，这个其实就是TestResult一个引用。那么我们可以这样写：

#coding=utf-8
import unittest
class Mydemo(unittest.TestCase):
    def test1(self):
        print "excute test1"
    def test2(self):
        if self._resultForDoCleanups.failures or self._resultForDoCleanups.errors:
            raise unittest.SkipTest("{} do not excute because {} is failed".format(self._testMethodName,self._resultForDoCleanups.failures[0][0]._testMethodName))
        print "excute test2"
        raise AssertionError("test2 fail")

    def test3(self):
        if self._resultForDoCleanups.failures or self._resultForDoCleanups.errors:
            raise unittest.SkipTest("{} do not excute because {} is failed".format(self._testMethodName,self._resultForDoCleanups.failures[0][0]._testMethodName))
        print "excute test3"
if name == 'main':
    unittest.main()

 运行结果如下：

.Fs
======================================================================
FAIL: test2 (main.Mydemo)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/Moudle/module_1/test4.py", line 10, in test2
    raise AssertionError("test2 fail")
AssertionError: test2 fail

----------------------------------------------------------------------
Ran 3 tests in 0.001s

FAILED (failures=1, skipped=1)
excute test1
excute test2

 可以了，我们看出，test2失败了，test3跳过;当然test2如果正确，test3会执行。目的是达到了，可是每个case都这样写不太好，我们想到了装饰器(不会自行百度)，在C:\Python27\Lib\unittest\case.py中新增如下代码：

def Myskip(func):
    def RebackTest(self):
        if self._resultForDoCleanups.failures or self._resultForDoCleanups.errors:
            raise unittest.SkipTest("{} do not excute because {} is failed".format(func.name,self._resultForDoCleanups.failures[0][0]._testMethodName))
        func(self)
    return  RebackTest

 然后C:\Python27\Lib\unittest\init.py中新增：

all = ['TestResult', 'TestCase', 'TestSuite',
           'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main',
           'defaultTestLoader', 'SkipTest', 'skip', 'skipIf', 'skipUnless',
           'expectedFailure', 'TextTestResult', 'installHandler',
           'registerResult', 'removeResult', 'removeHandler','Myskip']
......
from .case import (TestCase, FunctionTestCase, SkipTest, skip, skipIf,Myskip,
                   skipUnless, expectedFailure)

 最终我们这样写：

#coding=utf-8
import unittest
class Mydemo(unittest.TestCase):
    def test1(self):
        print "excute test1"
    @unittest.Myskip
    def test2(self):
        print "excute test2"
        raise AssertionError("test2 fail")
    @unittest.Myskip
    def test3(self):
        print "excute test3"
if name == 'main':
    unittest.main()

 好了，看上去还不错....关于其他的unnitest相关知识，不想再扯了，最后拓展HTMLTestRunner报告，这可能是大家关心的！写这个HTMLTestRunner的大神是在好久之前的了,基本能满足大家需求。但是，目前对于web自动化，我觉得至少要新增2个东西。第一个新增skip列：因为我可能会skip某些case；第二新增截图列,如果有错误我可能要截图。
打了这么久字不想再多说了....我给出全部代码，然后代码中我改变的地方我给出标记并加注释吧，完整代码如下：(可能有点长，但是要有点耐心)

#coding=utf-8
"""
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 = &#39;<link rel="stylesheet" href="my_stylesheet.css" type="text/css">&#39;

    # 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?
#coding=utf-8
import datetime
import io
import sys
reload(sys)
sys.setdefaultencoding(&#39;utf8&#39;)
import time
import unittest
import re
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: &#39;pass&#39;,
    1: &#39;fail&#39;,
    2: &#39;error&#39;,    
    }

    DEFAULT_TITLE = &#39;Unit Test Report&#39;
    DEFAULT_DESCRIPTION = &#39;&#39;

    # ------------------------------------------------------------------------
    # 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) == &#39;ft&#39;) {
            if (level < 1) {
                tr.className = &#39;hiddenRow&#39;;
            }
            else {
                tr.className = &#39;&#39;;
            }
        }
        if (id.substr(0,2) == &#39;pt&#39;) {
            if (level > 1) {
                tr.className = &#39;&#39;;
            }
            else {
                tr.className = &#39;hiddenRow&#39;;
            }
        }

        }
    }
}

function showClassDetail(cid, count) {
    var id_list = Array(count);
    var toHide = 1;
    for (var i = 0; i < count; i++) {
        tid0 = &#39;t&#39; + cid.substr(1) + &#39;.&#39; + (i+1);
        tid = &#39;f&#39; + tid0;
        tr = document.getElementById(tid);
        if (!tr) {
            tid = &#39;p&#39; + 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(&#39;p_&#39;+tid).style.display = &#39;none&#39;
            document.getElementById(tid).className = &#39;hiddenRow&#39;;
        }
        else {
            document.getElementById(tid).className = &#39;&#39;;
        }
    }
}


function showTestDetail(p_id){
    var details_p = document.getElementById(p_id)
    var displayState = details_p.style.display
    // alert(displayState)
    if (displayState != &#39;block&#39; ) {
        displayState = &#39;block&#39;
        details_p.style.display = &#39;block&#39;
    }
    else {
        details_p.style.display = &#39;none&#39;
    }
}


function html_escape(s) {
    s = s.replace(/&/g,&#39;&&#39;);
    s = s.replace(/</g,&#39;<&#39;);
    s = s.replace(/>/g,&#39;>&#39;);
    return s;
}

/* obsoleted by detail in <p>
function showOutput(id, name) {
    var w = window.open("", //url
                    name,
                    "resizable,scrollbars,status,width=800,height=450");
    d = w.document;
    d.write("<pre class="brush:php;toolbar:false">");
    d.write(html_escape(output_list[id]));
    d.write("\n");
    d.write("<a href=&#39;javascript:window.close()&#39;>close</a>\n");
    d.write("

\n");     d.close(); } */ --> %(heading)s %(report)s %(ending)s

以上がPythonの単体テストと拡張HTMLTestRunnerの詳細説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。