前言：

　　实际项目中，随着项目进度的开展，测试类会越来越多，可是直到现在我们还只会一个一个的单独运行测试类，这在实际项目实践中肯定是不可行的，在unittest中可以通过测试套件来解决该问题。
　　测试套件（TestSuite）是由多个测试用例（TestCase）组成的，当然也可以由多个子测试套件组成。
　　unittest中，把测试用例加载到测试套件的方式有如下方法：

1、方式一：通过addTest()方法对测试类内部的测试案例进行逐一添加

　　用unittest.TestSuite()实例化测试套件对象后，内部的addTest()方法对测试类内部的测试案例进行逐一添加。缺点：每次只能通过addTest()方法添加单个测试用例，如果一个模块下用例过多就不太实用了 
import unittest

class LoginTest(unittest.TestCase):
    def test_logindemo01(self):
        print('exec test_logindemo01')
        self.assertIsInstance('hello',str)
    def test_logindemo02(self):
        print('exec test_logindemo02')
        self.assertIsInstance(123,int)
    def test_logindemo03(self):
        print('exec test_logindemo03')
        self.assertIsInstance([1,2,3],list)

if __name__=='__main__':
    #方式一
    # login_suite=unittest.TestSuite()
    # login_suite.addTest(LoginTest('logindemo01'))#addTest类名(方法名)
    # login_suite.addTest(LoginTest('logindemo03'))
    runTest=unittest.main(defaultTest='login_suite')# 字符串格式 ’测试套件对象‘

2、方式二：通过makeSuite()方法，一次性将整个测试类文件下所有测试用例到suite中进行执行

　　用unittest.TestSuite()实例化测试套件对象后，使用makeSuite()方法，一次性将整个测试类文件下所有测试用例到suite中去。缺点：每次只能通过makeSuite()方法执行某个类下的测试用例，如果一个模块下存在多个类，则该方法就不太实用了 
import unittest

class LoginTest(unittest.TestCase):
    def test_logindemo01(self):
        print('exec test_logindemo01')
        self.assertIsInstance('hello',str)
    def test_logindemo02(self):
        print('exec test_logindemo02')
        self.assertIsInstance(123,int)
    def test_logindemo03(self):
        print('exec test_logindemo03')
        self.assertIsInstance([1,2,3],list)

if __name__=='__main__':
    #方式二
    #注意：使用makeSuite()方法是，测试用例函数名一定是”test“开头
    login_suite = unittest.TestSuite( unittest.makeSuite(LoginTest) )

3、方式三：通过TestLoader类用于自动创建一个测试集并把单个测试放入到测试集中进行执行

　　unittest提供一个TestLoader类用于自动创建一个测试集并把单个测试放入到测试集中。TestLoader自动运行以test开头的测试方法。
可以通过如下方法加载用例：
import unittest
import unittest_demo_04_TestSuite
import unittest_demo_05_TestLoader
class TestDemo_01(unittest.TestCase):
    def test_logindemo01(self):
        print('exec test_logindemo01')
        self.assertIsInstance(123,int)
    def test_logindemo02(self):
        print('exec test_logindemo02')
        self.assertIsInstance('hello',str)
    def test_logindemo03(self):
        print('exec test_logindemo03')
        self.assertIsInstance({"name":"张三"},dict)
class TestDemo_02(unittest.TestCase):
    def test_demo0201(self):
        print('exec test_demo0201')
        self.assertTrue([1,2,3])
    def test_demo0202(self):
        print('exec test_demo0202')
        self.assertEqual(1+1,2)
if __name__=='__main__':
    #TestLoader类使用时，必须导入需执行的模块。即使是当前本身所在的模块unittest_demo_05_TestLoader
    #loadTestsFromTestCase()方方法可用于执行一个模块中某一个类中的用例，用于执行类下的用例
    suite01=unittest.TestLoader().loadTestsFromTestCase(TestDemo_01)
    #loadTestsFromModule()方法是执行一个模块下的所有以test开头的方法（用例），用于执行模块下的用例
    '''suite02=unittest.TestLoader().loadTestsFromModule(unittest_demo_04_TestSuite)'''
    #loadTestsFromName()方法可用于执行一个模块中某一个类下的某一个以test开头的方法（用例），用于执行单个用例
    '''suite03=unittest.TestLoader().loadTestsFromName('unittest_demo_05_TestLoader.TestDemo_02.test_demo0202')'''
    # loadTestsFromName()方法可用于执行一个模块中某一个类中的用例，用于执行类下的用例
    '''suite04=unittest.TestLoader().loadTestsFromName('unittest_demo_05_TestLoader.TestDemo_02')'''
    unittest.main(defaultTest='suite01')

4、方式四：通过addTests()方法可以把多个子测试集合进行整合到一个大的测试集合中进行执行

　　　用unittest.TestSuite()实例化测试套件对象后，内部的addTests()方法可以把多个子测试集合进行整合到一个大的测试集合中。缺点：用该方法需要不断的去导入和添加测试用例模块，模块过多则不太实用了 
import unittest
import unittest_demo_04_TestSuite#导入测试用例所在的模块
import unittest_demo_05_TestLoader#导入测试用例所在的模块


#执行unittest_demo_04_TestSuite模块中LoginTest类下的test_logindemo02方法用例。执行单个用例
'''方式一:TestLoader类中loadTestsFromName()方法'''
# suite01=unittest.TestLoader().loadTestsFromName('unittest_demo_04_TestSuite.LoginTest.test_logindemo02')
'''方式二：TestSuite类中addTest()方法'''
suite01=unittest.TestSuite()
suite01.addTest(unittest_demo_04_TestSuite.LoginTest('test_logindemo02'))
#执行unittest_demo_05_TestLoader模块中TestDemo_01类下所有的用例。执行类下的用例
'''方式一:TestLoader类中loadTestsFromName()方法'''
# suite02=unittest.TestLoader().loadTestsFromName('unittest_demo_05_TestLoader.TestDemo_01')
'''方式二:TestSuite类中makeSuite()方法'''
suite02=unittest.TestSuite(unittest.makeSuite(unittest_demo_05_TestLoader.TestDemo_01))
#执行unittest_demo_05_TestLoader模块下所有的用例。执行模块下的用例
suite03=unittest.TestLoader().loadTestsFromName('unittest_demo_05_TestLoader')
main_suite=unittest.TestSuite()
#addTests()方法可以把多个子测试集合进行整合到一个大的测试集合中。执行子suite（套件）下的用例
main_suite.addTests(suite01)
main_suite.addTests(suite02)
main_suite.addTests(suite03)
unittest.main(defaultTest='main_suite')

 

5、方式五：通过discover()方法不需要像addTests()方法需要不断的去导入和添加测试用例模块。

　　当测试用例存在多个不同子目录下，我们用之前的把用例加载到测试集合中的方式还是不太方便，需要不断的去导入和添加测试用例模块，此时可以通过discover()方法来实现。方法如下：
　　discover(start_dir,pattern="test*.py",top_level_dir=None)
　　start_dir：要测试的模块名或测试用例目录；
　　pattern="test*.py"：表示用例文件名的匹配原则，例子中匹配文件名为以“test”开头的“.py”文件，星号“*”表示任意多个字符；
　　top_level_dir=None：测试模块的顶层目录，如果没有顶层目录，默认为None。
　　该方法通过从指定的开始目录递归到子目录中查找所有测试模块，并返回包含它们的TestSuite对象，只有与模块匹配测试文件和可导入的模块名称才会被加载。
　　如果一个测试文件的名字符合pattern，将检查该文件是否包含load_tests()函数，如果load_tests()函数存在，则由函数负责加载文本中的测试用例。如果不存在，就会执行loardTestsFromModule()，查找该文件中派生自TestCase的类包含的test开头的方法。
import os
import unittest

file_path=os.path.dirname(__file__)
test_one_path=os.path.join(file_path,'test_one')
'''
discover(start_dir,pattern="test*.py",top_level_dir=None)
start_dir：要测试的模块名或测试用例目录；
pattern="test*.py"：表示用例文件名的匹配原则，例子中匹配文件名为以“test”开头的“.py”文件，
星号“*”表示任意多个字符；
top_level_dir=None：测试模块的顶层目录，如果没有顶层目录，默认为None。

    该方法通过从指定的开始目录递归到子目录中查找所有测试模块，并返回包含它们的TestSuite对象，
只有与模块匹配测试文件和可导入的模块名称才会被加载。

    如果一个测试文件的名字符合pattern，将检查该文件是否包含load_tests()函数，如果load_tests()函数
存在，则由函数负责加载文本中的测试用例。如果不存在，就会执行loardTestsFromModule()，查找该文件中派生
自TestCase的类包含的test开头的方法。
'''
discover=unittest.defaultTestLoader.discover(start_dir=test_one_path,
                                             pattern='test_*.py',
                                             top_level_dir=test_one_path)
main_suite=unittest.TestSuite()
main_suite.addTest(discover)
unittest.main(defaultTest='main_suite')
 
金鳞岂是池中物，一遇风云便化龙。