Comment utiliser unittest, le framework de tests automatisés Python ?

1 unittest framework

unittest est un framework de tests unitaires pour python Il a principalement les fonctions suivantes : #🎜🎜 ## 🎜🎜#Assurer l'organisation et l'exécution des cas d'utilisation : Lorsque vous n'avez que quelques cas de test, vous n'avez pas besoin de considérer l'organisation des cas d'utilisation. Cependant, lorsque les cas de test atteignent des centaines ou des milliers, un grand nombre de cas d'utilisation. les cas de test sont empilés, ce qui entraîne des problèmes tels que l'évolutivité et la maintenabilité, il est temps d'envisager la spécification et l'organisation des cas d'utilisation. Le framework de tests unitaires est là pour résoudre ce problème.

Fournit des méthodes de comparaison riches : une fois le cas d'utilisation exécuté, les résultats réels doivent être comparés aux résultats attendus (assertion) pour déterminer si le cas d'utilisation peut se dérouler sans problème. Les tests unitaires fournissent généralement des méthodes d'assertion riches. Par exemple, les méthodes d'assertion telles que égalité/inégalité, inclusion/exclusion, Vrai/Faux, etc.

Fournit des journaux riches : lorsqu'un scénario de test ne s'exécute pas, il peut générer une raison d'échec claire, et lorsque tous les scénarios de test sont exécutés, il peut fournir des résultats d'exécution riches. Par exemple, la durée totale d'exécution, le nombre de cas d'utilisation ayant échoué, le nombre de cas d'utilisation réussis, etc.

Il existe quatre concepts très importants dans le test unitaire, le montage de test, le scénario de test, la suite de tests et le lanceur de tests.

Test Fixture

La construction et la destruction d'un environnement de scénario de test sont un montage, qui est réalisé en remplaçant les méthodes setUp() et TearDown().

La méthode setUp() peut être utilisée pour configurer l'environnement de test, comme par exemple obtenir le pilote du navigateur à tester, ou si vous avez besoin d'accéder à la base de données pendant le test, vous pouvez l'initialiser en établissant une connexion à la base de données dans setUp() .

tearDown() détruit l'environnement, ce qui peut fermer le navigateur, fermer la connexion à la base de données, effacer les données générées dans la base de données, etc.; exemple C'est juste un cas de test. Un scénario de test est un processus de test complet, comprenant l'établissement de l'environnement de préparation pré-test (setUp), le code pour implémenter le processus de test et la restauration de l'environnement post-test (tearDown). L'essence des tests unitaires (test unitaire) est ici. Un scénario de test est une unité de test complète qui peut vérifier une certaine fonction. Test Suite

La vérification d'une fonction nécessite souvent plusieurs cas de tests, qui peuvent être exécutés ensemble. Cela donne naissance au concept de suite de tests TestSuite. Test Suit est utilisé pour assembler plusieurs cas de test ensemble ;

L'exécution du test Test Runner est également un concept très important dans le framework unittest, le test est exécuté via la méthode run() fournie par la classe TextTestRunner. suite/cas de test.

from selenium import webdriver
import unittest
import time
import os
from selenium.common.exceptions import NoAlertPresentException
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
class Baidu1(unittest.TestCase):
    def setUp(self):
        print("-----setUp-----")
        self.driver = webdriver.Chrome()
        self.url = "https://www.baidu.com/"
        self.driver.maximize_window()
        time.sleep(3)
    def tearDown(self):
        print("-----tearDown-----")
        self.driver.quit()
    def test_hao(self):
        print("111111111")
        driver = self.driver
        url = self.url
        driver.get(url)
        driver.find_element(By.LINK_TEXT,"hao123").click()
        time.sleep(6)
    def test_hbaidu(self):
        print("22222222")
        driver = self.driver
        url = self.url
        driver.get(url)
        driver.find_element(By.ID,"kw").send_keys("unittest")
        driver.find_element(By.ID,"su").submit()
        time.sleep(5)
        print(driver.title)
        # self.assertNotEqual(driver.title, "百度一下_百度搜索", msg="不相等")
        # self.assertTrue("beautiful"=="beauty", msg="Not Equal!")
        time.sleep(6)
    def saveScreenAsPhoto(self, driver, file_name):
        if not os.path.exists("./image"):
            os.makedirs("./image")
        now = time.strftime("%Y%m%d-%H%M%S", time.localtime(time.time()))
        driver.get_screenshot_as_file("./image/" + now + "-" + file_name)
        time.sleep(3)
        print("3333333")
if __name__ == "__main__":
    unittest.main()

La classe Baidu1 dans ce script hérite de la classe unittest.TestCase, elle utilise donc le framework unittest pour organiser les cas de test (TestCase).

setUp() et setDown() sont des firmwares de test dans le framework unittest.

Les méthodes nommées commençant par test_ sont des méthodes de test et seront exécutées par défaut lors de l'exécution de la classe entière.

unittest fournit la méthode globale main(), qui peut facilement transformer un module de test unitaire en un script de test pouvant être exécuté directement

. La méthode main() recherche toutes les méthodes de test nommées "test" contenues dans ce module et les exécute automatiquement.

2 Script d'exécution par lots

2.1 Construire une suite de tests

Après avoir ajouté la fonction testée et le scénario de test correspondant, nous devons plusieurs cas de test sont organisés et exécutés ensemble, ce qui nécessite l'utilisation de la suite de tests Test Suite mentionnée ci-dessus

Supposons que nous ayons écrit deux fichiers testbaidu1.py et testbaidu2.py

testbaidu2. py

from selenium import webdriver
import unittest
import time
from selenium.common.exceptions import NoAlertPresentException
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
class Baidu2 (unittest.TestCase) :
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.baidu.com/"
        self.driver.maximize_window()
        self.verificationErrors=[]
        self.accept_next_alert = True
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)
    def test_hao(self):
        driver = self.driver
        driver.get(self.base_url)
        driver.find_element(By.LINK_TEXT,"新闻").click()
        time.sleep(6)
        self.assertTrue("123" == "1234", msg="not true")
        time.sleep(3)
    def test_baidusearch(self):
        driver = self.driver
        driver.get(self.base_url)
        driver.find_element(By.ID,"kw").clear()
        driver.find_element(By.ID,"kw").send_keys(u"unittest")
        driver.find_element(By.ID,"su").click()
    time.sleep(6)
    def is_element_present(self, how, what):
        try:
            self.driver.find_element(by=how, value=what)
        except NoSuchElementException as e:
            return False
        return True
    def is_alert_present(self):
        try:
            self.driver.switch_to.alert
        except NoAlertPresentException as e:
            return False
        return True
    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to.alert
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True
if __name__ == "__main__":
    unittest.main(verbosity=2)

addTest()

La méthode addTest() de la classe TestSuite peut assembler des méthodes de test dans différentes classes de tests dans une suite de tests mais addTest() ne peut qu'assembler. une méthode de test dans une classe dans la suite de tests à la fois. La méthode est la suivante :

Placez les méthodes de test dans testbaidu1.py et testbaidu2.py dans une suite de tests et implémentez-les dans testsuite.py.

testsuite.py

import unittest
from testUnittest import testbaidu1
from testUnittest import testbaidu2
def createsuite():
    #addTest
    suite = unittest.TestSuite()
    suite.addTest(testbaidu1.Baidu1("test_hao"))
    suite.addTest(testbaidu1.Baidu1("test_hbaidu"))
    suite.addTest(testbaidu2.Baidu2("test_hao"))
    suite.addTest(testbaidu2.Baidu2("test_baidusearch"))
    return suite
if __name__=="__main__":
    suite = createsuite()
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(suite)

Cependant, l'approche ci-dessus présente deux inconvénients, qui gênent l'exécution rapide du script et testsuite.py doit être modifié à chaque fois : #🎜🎜 ## 🎜🎜#Vous devez importer tous les fichiers py associés, tels que import testbaidu1 Chaque fois que vous ajoutez un nouveau script, vous devez en importer un

addTest ne peut ajouter qu'une seule méthode de test à la fois. time. S'il y en a 10 dans un fichier py Si la méthode de test doit être assemblée dans la suite de tests, elle doit être ajoutée 10 fois

L'application de makeSuite() et TestLoader() #🎜 🎜#

La méthode makeSuite() est fournie dans le framework unittest), makeSuite peut implémenter une suite de tests TestSuite composée de tous les cas de test de la classe de cas de test. Lorsque unittest appelle makeSuite, il lui suffit de réussir le test. nom de classe.

TestLoader est utilisé pour créer des suites de tests pour les classes et les modules. Généralement, TestLoader().loadTestsFromTestCase(TestClass) est utilisé pour charger les classes de test.

runall.py

import unittest,csv
import os,sys
import time
import testbaidu1
import testbaidu2
#手工添加案例到套件，
def createsuite():
    suite = unittest.TestSuite()
    #将测试用例加入到测试容器（套件）中
    suite.addTest(unittest.makeSuite(testbaidu1.Baidu1))
    suite.addTest(unittest.makeSuite(testbaidu2.Baidu2))
    return suite
'''
suite1 = unittest.TestLoader().loadTestsFromTestCase(testbaidu1.Baidu1)
suite2 = unittest.TestLoader().loadTestsFromTestCase(testbaidu2.Baidu2)
suite = unittest.TestSuite([suite1, suite2])
return suite
'''
if __name__=="__main__":
    suite=createsuite()
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(suite)

Après l'introduction de makeSuite() et TestLoader(), nous n'avons pas besoin d'un fichier py pour tester la classe, il suffit d'importer une fois.

application découverte()

discover 是通过递归的方式到其子目录中从指定的目录开始， 找到所有测试模块并返回一个包含它们对象的TestSuite ，然后进行加载与模式匹配唯一的测试文件，discover 参数分别为discover(dir,pattern,top_level_dir=None)

runall.py—注意路径

import unittest,csv
import os,sys
import time
#手工添加案例到套件，
def createsuite():
    discover=unittest.defaultTestLoader.discover("../testUnittest",pattern='test*.py',top_level_dir=None)
    print (discover)
    return discover
if __name__=="__main__":
    suite=createsuite()
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(suite)

2.2 用例的执行顺序

unittest 框架默认加载测试用例的顺序是根据ASCII 码的顺序，数字与字母的顺序为： 0 ~ 9,A ~ Z,a ~ z 。

对于测试目录与测试文件来说， unittest 框架同样是按照这个规则来加载测试用例

2.3 忽略用例执行

语法：

@unittest.skip(u'The function was canceled, neglects to perform thecase')

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoAlertPresentException
import unittest, time, re
class Baidu1(unittest.TestCase):
#test fixture，初始化环境
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.baidu.com/"
        self.verificationErrors = []
        self.accept_next_alert = True
    @unittest.skip("skipping")
    def test_baidusearch(self):
        driver = self.driver
        driver.get(self.base_url + "/")
        driver.find_element(By.ID,"kw").click()
        driver.find_element(By.ID,"kw").clear()
        driver.find_element(By.ID,"kw").send_keys(u"测试")
        driver.find_element(By.ID,"su").click()
        driver.find_element(By.ID,"su").click()
    def test_hao(self):
        driver = self.driver
        driver.get(self.base_url + "/")
        driver.find_element(By.LINK_TEXT,"hao123").click()
        self.assertEqual(u"hao123_上网从这里开始", driver.title)
#判断element是否存在，可删除
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException as e: return False
        return True
#判断alert是否存在，可删除
    def is_alert_present(self):
        try: self.driver.switch_to_alert()
        except NoAlertPresentException as e: return False
        return True
#关闭alert，可删除
    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to_alert()
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True
#test fixture，清除环境
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)
if __name__ == "__main__":
    #执行用例
    unittest.main()

3 unittest断言

自动化的测试中， 对于每个单独的case来说，一个case的执行结果中， 必然会有期望结果与实际结果， 来判断该case是通过还是失败， 在unittest 的库中提供了大量的实用方法来检查预期值与实际值， 来验证case的结果， 一般来说， 检查条件大体分为等价性， 逻辑比较以及其他， 如果给定的断言通过， 测试会继续执行到下一行的代码， 如果断言失败， 对应的case测试会立即停止或者生成错误信息( 一般打印错误信息即可) ，但是不要影响其他的case执行。

unittest 的单元测试库提供了标准的xUnit 断言方法。下面是一些常用的断言

断言方法	断言描述
assertEqual(arg1, arg2, msg=None)	验证arg1=arg2，不等则fail
assertNotEqual(arg1, arg2, msg=None)	验证arg1 != arg2, 相等则fail
assertTrue(expr, msg=None)	验证expr是true，如果为false，则fail
assertFalse(expr,msg=None)	验证expr是false，如果为true，则fail
assertIs(arg1, arg2, msg=None)	验证arg1、arg2是同一个对象，不是则fail
assertIsNot(arg1, arg2, msg=None)	验证arg1、arg2不是同一个对象，是则fail
assertIsNone(expr, msg=None)	验证expr是None，不是则fail
assertIsNotNone(expr, msg=None)	验证expr不是None，是则fail
assertIn(arg1, arg2, msg=None)	验证arg1是arg2的子串，不是则fail
assertNotIn(arg1, arg2, msg=None)	验证arg1不是arg2的子串，是则fail
assertIsInstance(obj, cls, msg=None)	验证obj是cls的实例，不是则fail
assertNotIsInstance(obj, cls,msg=None)	验证obj不是cls的实例，是则fail

4 HTML报告生成

脚本执行完毕之后，还需要看到HTML报告，下面我们就通过HTMLTestRunner.py 来生成测试报告。

修改runall.py

import unittest,csv
import os,sys
import time
import HTMLTestRunner
#手工添加案例到套件，
def createsuite():
    discover=unittest.defaultTestLoader.discover('../testUnittest',pattern='test*.py',top_level_dir=None)
    print (discover)
    return discover
if __name__=="__main__":
    curpath=sys.path[0]
    #取当前时间
    now=time.strftime("%Y-%m-%d-%H %M %S",time.localtime(time.time()))
    if not os.path.exists(curpath+'/resultreport'):
        os.makedirs(curpath+'/resultreport')
    filename=curpath+'/resultreport/'+now+'resultreport.html'
    with open(filename,'wb') as fp:
    #出html报告
        runner=HTMLTestRunner.HTMLTestRunner(stream=fp,title=u'测试报告',description=u'用例执行情况',verbosity=2)
        suite=createsuite()
        runner.run(suite)

5 异常捕捉与错误截图

用例不可能每一次运行都成功，肯定运行时候有不成功的时候。如果可以捕捉到错误，并且把错误截图保存，这将是一个非常棒的功能，也会给我们错误定位带来方便。

例如编写一个函数，关键语句为driver.get_screenshot_as_file：

def savescreenshot(self,driver,file_name):
if not os.path.exists('./image'):
	os.makedirs('./image')
now=time.strftime("%Y%m%d-%H%M%S",time.localtime(time.time()))
#截图保存
driver.get_screenshot_as_file('./image/'+now+'-'+file_name)
time.sleep(1)

示例：testscreenshot.py

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoAlertPresentException
import unittest, time, re
import os
class Baidu1(unittest.TestCase):
    #test fixture，初始化环境
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.baidu.com/"
        self.verificationErrors = []
        self.accept_next_alert = True
    #测试用例，必须以test开头
    def test_hao(self):
        driver = self.driver
        driver.get(self.base_url + "/")
        driver.find_element(By.LINK_TEXT,"hao123").click()
        time.sleep(2)
        try:
            self.assertEqual(u'hao_上网从这里开始', driver.title)
        except:
            self.savescreenshot(driver,'hao.png')
    #判断element是否存在，可删除
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException as e: return False
        return True
    #判断alert是否存在，可删除
    def is_alert_present(self):
        try: self.driver.switch_to_alert()
        except NoAlertPresentException as e: return False
        return True
    #关闭alert，可删除
    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to_alert()
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True
    #test fixture，清除环境
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)
    def savescreenshot(self,driver,file_name):
        if not os.path.exists('./image'):
            os.makedirs('./image')
            now=time.strftime("%Y%m%d-%H%M%S",time.localtime(time.time()))
            #截图保存
            driver.get_screenshot_as_file('./image/'+now+'-'+file_name)
            time.sleep(1)
if __name__ == "__main__":
    #执行用例
    unittest.main()
'''
可以增加verbosity参数，例如unittest.main(verbosity=2)
在主函数中，直接调用main() ，在main中加入verbosity=2 ，这样测试的结果就会显示的更加详细。
这里的verbosity 是一个选项, 表示测试结果的信息复杂度，有三个值:
0 ( 静默模式): 你只能获得总的测试用例数和总的结果比如总共100个失败,20 成功80
1 ( 默认模式): 非常类似静默模式只是在每个成功的用例前面有个“ . ” 每个失败的用例前面有个“F”
2 ( 详细模式): 测试结果会显示每个测试用例的所有相关的信息
'''

6 数据驱动

之前我们的case都是数据和代码在一起编写。考虑如下场景：

需要多次执行一个案例，比如baidu搜索，分别输入中文、英文、数字等进行搜索，这时候需要编写3个案例吗？有没有版本一次运行？

python 的unittest 没有自带数据驱动功能。所以如果使用unittest，同时又想使用数据驱动，那么就可以使用DDT来完成。

ddt的安装：

pip install ddt
python setup.py install

dd.ddt：

装饰类，也就是继承自TestCase的类。

ddt.data：

装饰测试方法。参数是一系列的值。

data(value) 一次性传入一个参数data(value1,value2,…) 一次性传入多个参数，需要用@unpack映射data(*解析数据的方法(txt/csv文件))

ddt.file_data：

装饰测试方法。参数是文件名。文件可以是json 或者 yaml类型。

注意，如果文件以”.yml”或者”.yaml”结尾，ddt会作为yaml类型处理，其他所有文件都会作为json文件处理。

如果文件中是列表，每个列表的值会作为测试用例参数，同时作为测试用例方法名后缀显示。

如果文件中是字典，字典的key会作为测试用例方法的后缀显示，字典的值会作为测试用例参数。

ddt.unpack：

传递的是复杂的数据结构时使用。比如使用元组或者列表，添加unpack之后，ddt会自动把元组或者列表对应到多个参数上。字典也可以这样处理。

Testddt.py：

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoAlertPresentException
import unittest, time, re
import os,sys,csv
from ddt import ddt, data, unpack ,file_data
def getCsv(file_name):
    rows=[]
    path=sys.path[0].replace('\testddt','')
    print (path)
    with open(path+'/data/'+file_name,'r+b') as f:
        readers=csv.reader(f,delimiter=',',quotechar='|')
        next(readers,None)
        for row in readers:
            temprows=[]
            for i in row:
                temprows.append(i.decode('gbk'))
            rows.append(temprows)
            return rows
#引入ddt
@ddt
class Testddt(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.baidu.com"
        self.verificationErrors = []
        self.accept_next_alert = True
    #测试用例，必须以test开头
    #增加ddt数据
    @data('selenium','unittest','Junit')
    #@data(2,3,4)
    #单变更时不使用unpack
    #@data([3, 2], [4, 3], [5, 3])
    # @data(*getCsv('test_baidu_data.csv'))
    #使用file_data需要在cmd窗口下运行，否则找不到文件
    #@file_data('test_data_list.json')
    # @unpack
    def test_hao(self,value,expected_value):
    # def test_hao(self,value):
        driver = self.driver
        driver.get(self.base_url + "/")
        driver.find_element(By.ID,"kw").clear()
        driver.find_element(By.ID,"kw").send_keys(value)
        driver.find_element(By.ID,"su").click()
        time.sleep(2)
        self.assertEqual(expected_value, driver.title)
        print (expected_value)
        print (driver.title)
    #判断element是否存在，可删除
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException as e: return False
        return True
    #判断alert是否存在，可删除
    def is_alert_present(self):
        try: self.driver.switch_to_alert()
        except NoAlertPresentException as e: return False
        return True
    #关闭alert，可删除
    def close_alert_and_get_its_text(self):
        try:
            alert = self.driver.switch_to_alert()
            alert_text = alert.text
            if self.accept_next_alert:
                alert.accept()
            else:
                alert.dismiss()
            return alert_text
        finally: self.accept_next_alert = True
    #test fixture，清除环境
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)
    def savescreenshot(self,driver,file_name):
        if not os.path.exists('./image'):
            os.makedirs('./image')
        now=time.strftime("%Y%m%d-%H%M%S",time.localtime(time.time()))
        #截图保存
        driver.get_screenshot_as_file('./image/'+now+'-'+file_name)
        time.sleep(1)
if __name__ == "__main__":
    #执行用例
    unittest.main()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!