1: Unit test, integration test, function test
The particle size is the smallest. Generally, the development team uses the white box method to test whether the main test units comply with the "design"; It refers to the inspection and verification of the smallest testable unit in the software
Between unit test and system test, the development team generally adopts the method of white box + black box to test, that is, to verify "design" and "requirements". It is mainly used to test the interface between templates, as well as some main business functions.
The particle size is the largest. Generally, the independent test team uses the black box method to test whether the main test system meets the "requirements specification"
What is a white box test and what is a black box test
White box: it is mainly used in the unit test stage. It is mainly used to test the code level and the internal logical structure of the program. The test methods include: statement coverage, decision coverage, condition coverage, path coverage and condition combination coverage
Black box: regardless of the internal structure and logical structure of the program, it mainly tests whether the function of the system meets the "requirements specification". Generally, there will be an input value and an output value, which will be compared with the expected value.
2: Important components of Unittest
Python has a built-in unit test framework, unittest module, which is used for unit testing. It encapsulates some result methods (assertions) returned by verification and some initialization operations before use case execution.
The core parts of unittest are: TestFixture, TestCase, TestSuite and TestRunner
It is used for the preparation, destruction and restoration of a test environment.
When the test case needs to prepare the test environment before each execution, restore the test environment after each test, such as connecting to the database and opening the browser before execution, and restore the database and close the browser after execution. At this time, you can enable testfixture
setUp(): prepare the environment and execute the preconditions of each test case;
tearDown(): environment restore, execute the post condition of each test case;
setUpClass(): the @ classmethod decorator must be used. The preconditions executed by all case s can only be run once;
tearDownClass(): the @ classmethod decorator must be used. All case s can only be run once after running;
TestCase: test case
A class class inherits unittest.TestCase, which is a test case
What are test cases?
It is a complete testing process, including setting up the environment before testing, executing the test code (run), and restoring the environment after testing (tearDown).
Test case naming rules
In the class inherited from unittest.TestCase, the name of the test method should start with test. Only the methods (test methods) defined beginning with test will be executed, and the execution order of the test cases will be sorted according to the ASCII value of the method name.
If you want to skip a test case, you need to add @ unittest. Skip ('description information ')
import unittest class Calc_testcase(unittest.TestCase): def setUp(self) : #Actions before test case method execution print("start") def test1(self): #test case resl = 4 self.assertEqual(resl,5) def tearDown(self) : #Actions after test case method execution print("end") if __name__ =="__main__": unittest.main() #Call the method starting with test in the test case
Test suite, which can collect multiple test cases together and execute the selected test cases together
suite = unittest.TestSuite()#Create test suite case_list = ["test1","test2"....] For case in case_list: suite.addTest(Class name(case))
suite = unittest.TestSuite()#Create test suite suite.addTest(Class name ("test1")) suite.addTest(Class name ("test2"))
suite = unittest.TestSuite()#Create test suite loader = unittest.TestLoader()# Create a load object suite .addTest(loader.loadTestsFromTestCase(Class name))
Execute test cases
Execute test suite/test cas through the run() method provided by the TextTestRunner class
runner = unittest.TextTestRunner(verbosity=2)
verbosity: indicates the detail level of test report information. There are three values in total. The default value is 2
Verify expected and actual results
assertEqual(a,b):Assert a and b The test case passes if it is equal. assertNotEqual(a,b):Assert a and b Whether it is equal or not. If it is not equal, the test case passes. assertTrue(x): Assert x whether True，yes True The test case passes. assertFalse(x): Assert x whether False，yes False The test case passes. assertIs(a,b):Assert a Is it b，Yes, the test case passes. assertNotIs(a,b):Assert a Is it b，If not, the test case passes. assertIsNone(x): Assert x whether None，yes None The test case passes. assertIsNotNone(x): Assert x whether None，no None The test case passes. assertIn(a,b): Assert a Is it b In, in b The test case passes. assertNotIn(a,b): Assert a Is it b In, not in b The test case passes. assertIsInstance(a,b): Assert a Yes, yes b An example of is that the test case passes. assertNotIsInstance(a,b): Assert a Yes, yes b If not, the test case passes.
4: Generate test report
The HTML format is HTMLTestRunner. HTMLTestRunner is an extension of the unittest framework of the Python standard library. It can generate an intuitive and clear HTML test report. The premise of use is to download HTMLTestRunner.py
with open("../report.html","wb") as f: HTMLTestRunner( stream=f, title="unit testing ", description="Test phase I", verbosity=2 ).run(suite)
Generate test report
stream: Specify how to output description: Familiar information to be displayed in the report title: Test report title verbosity : Indicates the detail level of test report information. There are three values in total. The default value is 2 0 (silent mode ): You can only get the total number of test cases and total results, such as 100 failures, 10 successes and 90 1 (Default mode): It is similar to the silent mode, but there is one in front of each successful use case. Each failed use case is preceded by a F 2 (Detailed mode): The test results will display all relevant information for each test case
1: Import unittest modular >>>import unittest 2:Write a class inheritance unittest.TestCase 3:call setUp(self), tearDown(self)Method to realize the operation before and after the test case 4:Method of writing test cases (1)The method must be test start,Otherwise in unittest.main()This method cannot be found in calling tests. (2)Set assertions to judge the expected results of input data and output data 5:Create a suite, store multiple test cases in the suite and execute them together() 6:Generate test report(python Bring or import HTMLTestRunner generate html Test report in format) 7: Run test cases unittest.main(),Call in the test case to test Method at the beginning
6: Code display
Unit test the developed code block
Develop the tested code
class Calc(): def add(self,a,b): c =a+b return c def redc(self,a,b): c = a-b print(c) if __name__ == "__main__": c = Calc() c.add(2,3) print(c.add(2,3))
Unit test code
from day.Calc import Calc import unittest c = Calc() #Instantiate developed classes class Test(unittest.TestCase):#Unittest unit test class must inherit unittest.TestCase def setUp(self): #Execute before test case print("start") def test001(self):#The test case must start with test res = c.add(2,1) #Method of calling addition self.assertEqual (res,5) #Assertion, comparison between expected results and actual results def test002(self):#The test case must start with test res = c.redc(2,3) #Method of calling subtraction self.assertEqual (res,-1) #Assertion, comparison between expected results and actual results def tearDown(self):#Execute after the test case is completed print("end") if __name__ == '__main__': unittest.main()
7: Read file
Read xml file
from xml.dom import minidom class Readxml(): def read_xml(self,filename,onename,twoname): root =minidom.parse(filename) firstnode =root.getElementsByTagName(onename) secondnode=firstnode.getElementsByTagName(twoname).firstChild.data return secondnode
Read csv file
import csv #Import csv module class ReadCsv(): def read_csv(self): item = #Define an empty list c = csv.reader(open("../commonDemo/test1.csv","r")) #Get csv file object for csv_i in c: item.append(csv_i) #Add the acquired data to the list return item r = ReadCsv() print(r.read_csv())