python之setUp,setUpClass,及setUpModule的区别

分装加减乘除函数

class MathOperation:
    """
    定义数学运算
    """
    def __init__(self,first_num,second_num):
        self.first_num,self.second_num = first_num,second_num

    def add(self):
        return self.first_num + self.second_num

    def minus(self):
        return self.first_num - self.second_num

    def multiply(self):
        return self.first_num * self.second_num

    def divide(self):
        try:
            return round(self.first_num/self.second_num,2)
        except ZeroDivisionError:
            return "出现除0错误"

1.setUp
每个测试用例执行之前会执行

# 先导入模块
import unittest
import inspect

# 导入自定义模块
from lin.math_operation import MathOperation as MathOper


class TestMulti(unittest.TestCase):
    """
    测试两数相乘
    """
    def setUp(self):
        """
        重写父类的方法
        每个测试用例执行之前会执行
        :return:
        """
        print("{:=^40s}".format("开始执行测试用例"))
        self.file_name = "record_run_result1.txt"
        self.file = open(self.file_name,mode="a",encoding="utf-8")
        self.file.write("{:=^40s}\n".format("开始执行测试用例"))

    def tearDown(self):
        """
        每个测试用例执行之后会执行
        :return:
        """
        print("{:=^40s}\n".format("测试用例执行结束"))
        self.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
        self.file.close()

    def test_two_neg_multi(self):
        """
        1.测试两个负数相乘
        :return:
        """
        # # 定义一个文件路径
        # file_name = "record_run_result.txt"
        # print("打开[{}]文件".format(file_name))
        # file = open(file_name,mode="a",encoding="utf-8")  # 以追加的模式打开一个文件夹
        # self.file.write("{:=^40s}\n".format("开始执行用例"))

        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,-4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg = "测试两个负数相乘"
        try:
            self.assertEqual(expect_result,real_result,msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg,"Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg,"Pass"))

        # finally:
        #     # 用例执行结束,("关闭[{}]文件".format(file_name))
        #     file.write("{:=^40s}\n\n".format("用例执行结束"))
        #     file.close()



    def test_neg_pos_multi(self):
        """
        2.测试一个负数与一个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,4).multiply()
        # 定义期望结果
        expect_result = -12
        # 验证实际结果与预期结果是否一致
        msg="测试一个负数与一个正数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_two_pos_multi(self):
        """
        测试两个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(3,4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg="测试两个负数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_zero_multi(self):
        """
        4.测试两个0数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(0,0).multiply()
        # 定义期望结果
        expect_result = 0
        # 验证实际结果与预期结果是否一致
        msg="测试两个0数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))


class TestDivide(unittest.TestCase):
    """
    测试两数相除
    """
    def setUp(self):
        """
        重写父类的方法
        在每个测试类执行之前运行
        :return:
        """
        self.file_name = "record_run_result1.txt"
        self.file = open(self.file_name,mode="a",encoding="utf-8")
        self.file.write("{:=^40s}\n".format("开始执行测试用例"))

    def tearDown(self):
        """
        在每个测试类执行之后运行
        :return:
        """
        self.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
        self.file.close()

    def test_two_neg_divi(self):
        """
        测试两个正数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        # 获取实际结果
        real_result = MathOper(8,4).divide()
        # 定义期望结果
        except_result = 2
        msg = "测试两个正数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            self.file.write("{},执行结果为:{},\n具体异常为{}\n".format(msg,"Fail"))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_neg_pos_divi(self):
        """
        测试一个正数一个负数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(8,-2).divide()
        except_result = -4
        msg = "测试一个正数一个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            self.file.write("{},执行的结果为:{}\n,具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_two_pos_divi(self):
        """
        测试两个负数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(-8,-2).divide()
        except_result = 4
        msg = "测试两个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg)
        except AssertionError as e:
            self.file.write("{},执行的结果为:{}\n具体异常为{}\n".format(msg,"Fali",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_zero_divi(self):
        """
        测试除0错误
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(8,0).divide()
        except_result = "出现除0错误"
        msg="测试除0错误"
        try:
            self.assertEqual(except_result,real_result,msg)
        except AssertionError as e:
            self.file.write("{},执行的结果为:{}\n具体异常为{}\n".format(msg,"Fail",e))
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

if __name__ == '__main__':
    unittest.main()

2.setUpClass
在每个测试类执行之前运行

# 先导入模块
import unittest
import inspect

# 导入自定义模块
from lin.math_operation import MathOperation as MathOper


class TestMulti(unittest.TestCase):
    """
    测试两数相乘
    """
    @classmethod
    def setUpClass(cls):
        """
        在每个测试类执行之前运行
        :return:
        """
        cls.file_name = "record_run_result1.txt"
        cls.file = open(cls.file_name,mode="a",encoding="utf-8")
        cls.file.write("{:=^40s}\n".format("开始执行测试用例"))
    # def setUp(self):
    #     """
    #     重写父类的方法
    #     每个测试用例执行之前会执行
    #     :return:
    #     """
    #     print("{:=^40s}".format("开始执行测试用例"))
    #     self.file_name = "record_run_result1.txt"
    #     self.file = open(self.file_name,mode="a",encoding="utf-8")
    #     self.file.write("{:=^40s}\n".format("开始执行测试用例"))

    @classmethod
    def  tearDownClass(cls):
        """
        在每个测试类执行之后运行
        :return:
        """
        cls.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
        cls.file.close()

    # def tearDown(self):
    #     """
    #     每个测试用例执行之后会执行
    #     :return:
    #     """
    #     print("{:=^40s}\n".format("测试用例执行结束"))
    #     self.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
    #     self.file.close()

    def test_two_neg_multi(self):
        """
        1.测试两个负数相乘
        :return:
        """
        # # 定义一个文件路径
        # file_name = "record_run_result.txt"
        # print("打开[{}]文件".format(file_name))
        # file = open(file_name,mode="a",encoding="utf-8")  # 以追加的模式打开一个文件夹
        # self.file.write("{:=^40s}\n".format("开始执行用例"))

        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,-4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg = "测试两个负数相乘"
        try:
            self.assertEqual(expect_result,real_result,msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg,"Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg,"Pass"))

        # finally:
        #     # 用例执行结束,("关闭[{}]文件".format(file_name))
        #     file.write("{:=^40s}\n\n".format("用例执行结束"))
        #     file.close()



    def test_neg_pos_multi(self):
        """
        2.测试一个负数与一个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,4).multiply()
        # 定义期望结果
        expect_result = -12
        # 验证实际结果与预期结果是否一致
        msg="测试一个负数与一个正数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_two_pos_multi(self):
        """
        测试两个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(3,4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg="测试两个负数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_zero_multi(self):
        """
        4.测试两个0数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(0,0).multiply()
        # 定义期望结果
        expect_result = 0
        # 验证实际结果与预期结果是否一致
        msg="测试两个0数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            self.file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            self.file.write("{},执行结果为:{}\n".format(msg, "Pass"))


class TestDivide(unittest.TestCase):
    """
    测试两数相除
    """

    @classmethod
    def setUpClass(cls):
        """
        在每个测试类执行之前运行
        :return:
        """
        cls.file_name = "record_run_result1.txt"
        cls.file = open(cls.file_name, mode="a", encoding="utf-8")
        cls.file.write("{:=^40s}\n".format("开始执行测试用例"))

    @classmethod
    def tearDownClass(cls):
        """
        在每个测试类执行之后运行
        :return:
        """
        cls.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
        cls.file.close()

    # def setUp(self):
    #     """
    #     重写父类的方法
    #     在每个测试类执行之前运行
    #     :return:
    #     """
    #     self.file_name = "record_run_result1.txt"
    #     self.file = open(self.file_name,mode="a",encoding="utf-8")
    #     self.file.write("{:=^40s}\n".format("开始执行测试用例"))
    #
    # def tearDown(self):
    #     """
    #     在每个测试类执行之后运行
    #     :return:
    #     """
    #     self.file.write("{:=^40s}\n\n".format("测试用例执行结束"))
    #     self.file.close()

    def test_two_neg_divi(self):
        """
        测试两个正数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        # 获取实际结果
        real_result = MathOper(8,4).divide()
        # 定义期望结果
        except_result = 2
        msg = "测试两个正数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            self.file.write("{},执行结果为:{},\n具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_neg_pos_divi(self):
        """
        测试一个正数一个负数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(8,-2).divide()
        except_result = -4
        msg = "测试一个正数一个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            self.file.write("{},执行的结果为:{}\n,具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_two_pos_divi(self):
        """
        测试两个负数相除
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(-8,-2).divide()
        except_result = -4
        msg = "测试两个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg)
        except AssertionError as e:
            print(e)
            self.file.write("{},执行的结果为:{}\n具体异常为{}\n".format(msg,"Fali",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_zero_divi(self):
        """
        测试除0错误
        :return:
        """
        self.file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(8,0).divide()
        except_result = "出现除0错误"
        msg="测试除0错误"
        try:
            self.assertEqual(except_result,real_result,msg)
        except AssertionError as e:
            self.file.write("{},执行的结果为:{}\n具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            self.file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

if __name__ == '__main__':
    unittest.main()

3.setUpMidule
解决每个测试类开启关闭文件的问题
在所有测试类在调用之前会被执行一次,函数名是固定写法,会被unittest框架自动识别

# 解决多个测试类,记录执行日志的问题
# 会使用def  setUpModule和def tearDownModule函数


# 先导入模块
import unittest
import inspect

# 导入自定义模块
from lin.math_operation import MathOperation as MathOper


def setUpModule():
    """
    解决每个测试类开启关闭文件的问题
    在所有测试类在调用之前会被执行一次,函数名是固定写法,会被unittest框架自动识别
    :return:
    """
    global file_name
    global file
    file_name = "record_run_result1.txt"
    file = open(file_name,mode="a",encoding="utf-8")
    file.write("{:=^40s}\n".format("开始执行测试用例"))

def tearDownModule():
    file.write("{:=^40s}\n\n".format("测试用例执行结束"))
    file.close()

class TestMulti(unittest.TestCase):
    """
    测试两数相乘
    """



    def test_two_neg_multi(self):
        """
        1.测试两个负数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,-4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg = "测试两个负数相乘"
        try:
            self.assertEqual(expect_result,real_result,msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg,"Fail"))
            raise e
        else:
            file.write("{},执行结果为:{}\n".format(msg,"Pass"))


    def test_neg_pos_multi(self):
        """
        2.测试一个负数与一个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(-3,4).multiply()
        # 定义期望结果
        expect_result = -12
        # 验证实际结果与预期结果是否一致
        msg="测试一个负数与一个正数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_two_pos_multi(self):
        """
        测试两个正数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(3,4).multiply()
        # 定义期望结果
        expect_result = 12
        # 验证实际结果与预期结果是否一致
        msg="测试两个负数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            file.write("{},执行结果为:{}\n".format(msg, "Pass"))

    def test_zero_multi(self):
        """
        4.测试两个0数相乘
        :return:
        """
        # 通过查看当前运行的实例方法名称
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        print("\nRunning Test Method:{}".format(inspect.stack()[0][3]))
        # 获取两个负数相乘的实际结果
        real_result = MathOper(0,0).multiply()
        # 定义期望结果
        expect_result = 0
        # 验证实际结果与预期结果是否一致
        msg="测试两个0数相乘失败"
        try:
            self.assertEqual(expect_result, real_result, msg=msg)
        except AssertionError as e:
            print("具体的异常为{}".format(e))
            # raise 关键字是将某个异常主动抛出
            file.write("{},执行结果为:{}\n具体异常为:{}\n".format(msg, "Fail"))
            raise e
        else:
            file.write("{},执行结果为:{}\n".format(msg, "Pass"))


class TestDivide(unittest.TestCase):
    """
    测试两数相除
    """



    def test_two_neg_divi(self):
        """
        测试两个正数相除
        :return:
        """
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        # 获取实际结果
        real_result = MathOper(8,4).divide()
        # 定义期望结果
        except_result = 2
        msg = "测试两个正数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            file.write("{},执行结果为:{},\n具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_neg_pos_divi(self):
        """
        测试一个正数一个负数相除
        :return:
        """
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(8,-2).divide()
        except_result = -4
        msg = "测试一个正数一个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg=msg)
        except AssertionError as e:
            file.write("{},执行的结果为:{}\n,具体异常为{}\n".format(msg,"Fail",e))
            raise e
        else:
            file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    def test_two_pos_divi(self):
        """
        测试两个负数相除
        :return:
        """
        file.write("Running Test Method:{}\n".format(inspect.stack()[0][3]))
        real_result = MathOper(-8,-2).divide()
        except_result = 4
        msg = "测试两个负数相除"
        try:
            self.assertEqual(except_result,real_result,msg)
        except AssertionError as e:
            print(e)
            file.write("{},执行的结果为:{}\n具体异常为{}\n".format(msg,"Fali",e))
            raise e
        else:
            file.write("{},执行的结果为:{}\n".format(msg,"Pass"))

    @unittest.skip("test_zero_divi")  # 跳过该条用例