python+unittest框架第二天unittest之简单认识Test Suite：测试套件

　　今天了解下测试套件Test Suite，什么是测试套件，测试套件是由多个Test Case测试用例组成的，当然也可以由多个子测试套件组成。

接下来看下如果构建测试套件，构建测试套件的方法：

1、用unittest.TestSuite()实例化测试套件对象后，内部的addTest()方法对测试类内部的测试案例进行逐一添加。

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver

 class page_baidu(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类

     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，不需要实例化类对象就可以调用方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页链接'''
     def test_baidu_001(self):     #案例001  测试进入百度新闻界面
         '''测试百度首新闻链接'''
         self.driver.find_element_by_link_text('新闻').click()    #点击百度页面，超链接【新闻】两个字
         t.sleep(2)     #设置强制等待2秒，就是必须等待，用导入的time中的sleep方法，不是全局性，哪里需要设置到哪里，局部的
         self.driver.back()
     def test_baidu_002(self):      #案例002  测试进入百度地图界面
         '''测试百度首地图链接'''
         self.driver.find_element_by_link_text('地图').click()   ##点击百度页面，超链接【地图】两个字
         t.sleep(2)
         self.driver.back()

     '''以下案例是测试百度首页搜索'''
     def test_baidu_003(self):
         '''测试百度首页搜索功能'''
         self.driver.find_element_by_id('kw').send_keys('你好朋友')
         self.driver.back()
 if __name__ =='__main__':
     suite =unittest.TestSuite()    #对测试套件这个类进行实例化对象的操作，方便后面调用它里面的方法
     suite.addTest(page_baidu('test_baidu_001'))   #addTest()是TestSuite()类中的添加测试用例的方法
     suite.addTest(page_baidu('test_baidu_002'))   #我们用addTest()方法添加page_baidu()这个测试类中的测试案例
     suite.addTest(page_baidu('test_baidu_003'))
     unittest.TextTestRunner(verbosity=2).run(suite)   #用TextTestResult生成测试结果，结果是根据测试套件中的案例生成

这样的方法很奇怪，如果测试类中有100个测试案例，我要这样suite.addTest(page_baidu('第N个测试点')) 去添加100个吗？这样的代码冗余是不是太多了~

所以接下来我们看第二个方法:一次性将整个测试案例类中的所有案例都添加到测试套件中

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver

 class page_baidu(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类

     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，不需要实例化类对象就可以调用方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页链接'''
     def test_baidu_001(self):     #案例001  测试进入百度新闻界面
         '''测试百度首新闻链接'''
         self.driver.find_element_by_link_text('新闻').click()    #点击百度页面，超链接【新闻】两个字
         t.sleep(2)     #设置强制等待2秒，就是必须等待，用导入的time中的sleep方法，不是全局性，哪里需要设置到哪里，局部的
         self.driver.back()
     def test_baidu_002(self):      #案例002  测试进入百度地图界面
         '''测试百度首地图链接'''
         self.driver.find_element_by_link_text('地图').click()   ##点击百度页面，超链接【地图】两个字
         t.sleep(2)
         self.driver.back()

     '''以下案例是测试百度首页搜索'''
     def test_baidu_003(self):
         '''测试百度首页搜索功能'''
         self.driver.find_element_by_id('kw').send_keys('你好朋友')
         self.driver.back()
 if __name__ =='__main__':
     suite =unittest.TestSuite()    #对测试套件这个类进行实例化对象的操作，方便后面调用它里面的方法
     suite.addTest(page_baidu())   #addTest()是TestSuite()类中的添加测试用例的方法,用addTest()方法添加page_baidu()这个测试类中的所有测试案例
     unittest.TextTestRunner(verbosity=2).run(suite)   #用TextTestResult生成测试结果，结果是根据测试套件中的案例生成

一般在将测试类中的所有测试案例放入套件中用makeSuite()方法，他是unittest中的方法。

makeSuite()：一次性将整个，测试类文件下所有测试用例到suite中去。代码：注意！！makeSuite()  这个方法括号中的参数是一个类哦！！！

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver

 class page_baidu(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类

     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，不需要实例化类对象就可以调用方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页链接'''
     def test_baidu_001(self):     #案例001  测试进入百度新闻界面
         '''测试百度首新闻链接'''
         self.driver.find_element_by_link_text('新闻').click()    #点击百度页面，超链接【新闻】两个字
         t.sleep(2)     #设置强制等待2秒，就是必须等待，用导入的time中的sleep方法，不是全局性，哪里需要设置到哪里，局部的
         self.driver.back()
     def test_baidu_002(self):      #案例002  测试进入百度地图界面
         '''测试百度首地图链接'''
         self.driver.find_element_by_link_text('地图').click()   ##点击百度页面，超链接【地图】两个字
         t.sleep(2)
         self.driver.back()

     '''以下案例是测试百度首页搜索'''
     def test_baidu_003(self):
         '''测试百度首页搜索功能'''
         self.driver.find_element_by_id('kw').send_keys('你好朋友')
         self.driver.back()
 if __name__ =='__main__':
     # suite =unittest.TestSuite()    #对测试套件这个类进行实例化对象的操作，方便后面调用它里面的方法
     # suite.unittest.makeSuite(page_baidu)  #一次性将整个，测试类文件下所有测试用例到suite中去。
     suite = unittest.TestSuite(unittest.makeSuite(page_baidu))  #将上面的两行代码合并成一行来写
     unittest.TextTestRunner(verbosity=2).run(suite)   #用TextTestResult生成测试结果，结果是根据测试套件中的案例生成

我们再看看TestLoader()这个类中提供的几种创建测试套件（test Suite）的方法:

1、TestLoader().loadTestsFromTestCase(testCaseClass)   ：该方法是可以将类中的案例都加载到测试套件中，括号中的参数是类

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver

 class page_baidu(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类

     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，不需要实例化类对象就可以调用方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页链接'''
     def test_baidu_001(self):     #案例001  测试进入百度新闻界面
         '''测试百度首新闻链接'''
         self.driver.find_element_by_link_text('新闻').click()    #点击百度页面，超链接【新闻】两个字
         t.sleep(2)     #设置强制等待2秒，就是必须等待，用导入的time中的sleep方法，不是全局性，哪里需要设置到哪里，局部的
         self.driver.back()
     def test_baidu_002(self):      #案例002  测试进入百度地图界面
         '''测试百度首地图链接'''
         self.driver.find_element_by_link_text('地图').click()   ##点击百度页面，超链接【地图】两个字
         t.sleep(2)
         self.driver.back()
 if __name__ =='__main__':
     suite = unittest.TestLoader().loadTestsFromTestCase(page_baidu)  #TestLoader()这个类提供了loadTestsFromTestCase()方法，参数是类或者子类。
     unittest.TextTestRunner(verbosity=2).run(suite)   #用TextTestResult生成测试结果，结果是根据测试套件中的案例生成

2、TestLoader().loadTestsFromModule(module, pattern=None)   :该方法是加载一个模块文件中的所有测试类，一个  .py文件就是一个模块哦，前面笔记有详细说过。

我们看下，下面的笔记，笔记中的.py文件的名字是：bokeyuan--unitagin.py     此模块下面有两个测试类，第一个类是：page_baidu_lianjie

第二个类是：page_baidu_sousuo     所以加载的是这个模块下面的两个类中的所有测试案例方法。记住，括号中的参数是.py文件名，另外记得带英文引号！！！

看代码：

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver

 class page_baidu_lianjie(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类
     '''这个类中的方法是测试百度首页链接'''
     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，不需要实例化类对象就可以调用方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页链接'''
     def test_baidu_001(self):     #案例001  测试进入百度新闻界面
         '''测试百度首新闻链接'''
         self.driver.find_element_by_link_text('新闻').click()    #点击百度页面，超链接【新闻】两个字
         t.sleep(2)     #设置强制等待2秒，就是必须等待，用导入的time中的sleep方法，不是全局性，哪里需要设置到哪里，局部的
         self.driver.back()
     def test_baidu_002(self):      #案例002  测试进入百度地图界面
         '''测试百度首地图链接'''
         self.driver.find_element_by_link_text('地图').click()   ##点击百度页面，超链接【地图】两个字
         t.sleep(2)
         self.driver.back()

 class page_baidu_sousuo(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类
     '''这个类中的方法是测试百度首页搜索功能'''
     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，类本身就不在需要实例化类对象就可以调用此方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页搜索功能'''
     def test_baidu_003(self):
         '''测试百度首页搜索功能'''
         self.driver.find_element_by_id('kw').send_keys('你好朋友')

 if __name__ =='__main__':
     suite = unittest.TestLoader().loadTestsFromModule('bokeyuan--unitagin.py')   #TestLoader()类中的loadTestsFromModule方法，提供加载模块中的所有测试类，括号中的参数是模块文件名称
     unittest.TextTestRunner(verbosity=2).run(suite)   #用TextTestResult生成测试结果，结果是根据测试套件中的案例生成

代码越来越长，所以截图是截取重要部分~~~

接下来我们优化之前的代码，将测试套件这部分代码，封装成方法：

 import unittest                     #导入unittest
 import time as t                    #导入time  设置别名 t
 from selenium import webdriver      #导入selenium中的webdriver
 class page_baidu_sousuo(unittest.TestCase):       #定义一个类，并继承unittest.TestCase类
     '''这个类中的方法是测试百度首页搜索功能'''
     @classmethod                           #使用 @classmethod  装饰器函数，把方法变成类方法，可以直接调用方法，类本身就不在需要实例化类对象就可以调用此方法
     def setUp(cls):
         cls.driver = webdriver.Chrome()
         cls.driver.maximize_window()
         cls.driver.implicitly_wait(15)
         cls.driver.get(r'http://www.baidu.com')
         t.sleep(2)
     @classmethod
     def tearDown(cls):
         cls.driver.quit()

     '''以下案例是测试百度首页搜索功能'''
     def test_baidu_003(self):
         '''测试百度首页搜索功能'''
         self.driver.find_element_by_id('kw').send_keys('你好朋友')

     @staticmethod   #静态方法分离测试套件，不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。类.方法().看最后的代码调用：page_baidu_lianjie.suite()
     def suite():
         suite = unittest.TestSuite(unittest.makeSuite(page_baidu_sousuo))   #将测试套件单独分离出，封装成方法，直接调用，以后就不用再每次都写
         return suite  #将测试套件返回，如果不写return返回，那么将不会将内容返回给调用方下面的run()

 if __name__ =='__main__':
     unittest.TextTestRunner(verbosity=2).run(page_baidu_sousuo.suite())   #run()接收封装的suite()方法的返回参数，进行测试套件的执行载入，然后生成报告

总结：
1、TestSuite类中的addTest()方法来载入单体案例
2、TestSuite类中的addTest()方法来载入类中的整个案例，就是直接写测试类的类名
3、TestSuite类中的makeSuite()方法，一次性将整个，测试类文件下所有测试用例到suite中去。代码：注意！！makeSuite()  这个方法括号中的参数是一个类哦！！！
4、利用unittest中的TestLoader()类的loadTestsFromTestCase(testCaseClass)方法    ：该方法是可以将类中的案例都加载到测试套件中，括号中的参数是类名
5、利用unittest中的TestLoader()类的loadTestsFromModule(module, pattern=None)方法   ：该方法是加载一个模块文件中的所有测试类，一个 .py文件就是一个模块哦
6、测试套件可以单独分离出去，利用静态函数，将它封装成一个方法，可以直接类.函数()的调用方式，不需要实例化参数，因为有装饰器函数@staticmethod

重点，重点！！！----》要使用某个类的方法，需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。

下面是两个装饰器函数的区别：

@staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。

接下来的笔记就是测试固件的分离以及后续的断言~~~

-----来自新手的笔记，希望能帮助大初学者，如果有错误的笔记，希望大家给予帮助！尽量把代码的注释写精准，方便后续学习，也方便其他初学者参考~~谢谢各位！