day13作业：单元测试框架（注册案例）

对下面功能函数 设计用例进行单元测试，

要求

1、 设计至少五条用例

2、至少用两种方式往测试集合（套件）中添加测试用例

3、执行测试集合（套件）中的测试用例，生成测试报告

# 设计用例，对此功能函数进行单元测试
users = [{'user': 'python23', 'password': '123456'}]

def register(username, password1, password2):
    # 注册功能
    for user in users:  # 遍历出所有账号，判断账号是否存在
        if username == user['user']:
            # 账号存在
            return {"code": 0, "msg": "该账户已存在"}
    else:
        if password1 != password2:
            # 两次密码不一致
            return {"code": 0, "msg": "两次密码不一致"}
        else:
            # 账号不存在 密码不重复，判断账号密码长度是否在 6-18位之间
            if 6 <= len(username) >= 6 and 6 <= len(password1) <= 18:
                # 注册账号
                users.append({'user': username, 'password': password2})
                return {"code": 1, "msg": "注册成功"}
            else:
                # 账号密码长度不对，注册失败
                return {"code": 0, "msg": "账号和密码必须在6-18位之间"}



#  上面已经被注册的账号：python23

#  入参三个：  账号    密码1  密码2         
#  账号未被注册过，两个密码一样才能注册成功，其他情况都注册失败，对应的结果如下：


# 注册成功               预期结果：{"code": 1, "msg": "注册成功"}
# 两次密码不一致         预期结果：{"code": 0, "msg": "两次密码不一致"}
# 账户已存在             预期结果：{"code": 0, "msg": "该账户已存在"}
# 密码不在6-18位之间     预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
           

第一个文件：register.py

# ==========================
# @time:2019/10/28 20:10
# @Author:coco
# @File:register.py
# @software:PyCharm
# ============================

users = [{'user': 'python23', 'password': '1123456'}]


def register(username, password1, passwrod2):
    # 注册功能
    for user in users:  # 遍历出所有的账号，判断账号是否存在
        if username == user['user']:
            # 账号存在
            return {"code": 0, "msg": "该账号已存在"}
        else:
            if password1 != passwrod2:
                # 两次密码不一致
                return {"code": 0, "msg": "两次密码不一致"}
            else:
                # 账号不存在，密码重复，判断账号密码长度是否在6-18位之间
                if 6 <= len(username) >= 6 and 6 <= len(password1) <= 18:
                    # 注册账号
                    users.append({'user': username, 'password': passwrod2})
                    return {"code": 1, "msg": "注册成功"}
                else:
                    # 账号密码长度不对，注册失败
                    return {"code": 0, "msg": "账号和密码必须在6-18位之间"}

           

第二个文件：testcases.py

# ==========================
# @time:2019/10/28 20:27
# @Author:coco
# @File:testcases.py
# @software:PyCharm
# ============================
"""
注册成功               预期结果：{"code": 1, "msg": "注册成功"}
两次密码不一致         预期结果：{"code": 0, "msg": "两次密码不一致"}
账号已存在             预期结果：{"code": 0, "msg": "该账号已存在"}
密码长度小于6     预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
密码长度大于18    预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
账号长度小于6     预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
账号长度大于18    预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
账号为空          预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}
密码为空          预期结果：{"code": 0, "msg": "账号和密码必须在6-18位之间"}


"""

import time
import unittest
from register import register

class RegisterTestCase(unittest.TestCase):

    def sestUp(self):
        print('用例{}开始执行了'.format(self))

    def tearDown(self):
        print('用例{}执行结束了'.format(self))

    @classmethod
    def setUpClass(cls) :
        import time
        time.sleep(2)
        print('测试用例类{}开始执行了'.format(cls))

    @classmethod
    def tearDownClass(cls):
        time.sleep(1)
        print('测试用例类{}执行结束了'.format(cls))

    def test_register(self):
        """正常注册"""
        # 预期结果
        excepted={"code": 1, "msg": "注册成功"}
        # 参数：data
        data=('python1','123456','123456')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res=register(*data)
        # 比对预期结果，和实际结果是否一致
        self.assertEqual(excepted,res)

    def test_password_dis(self):
        """两次密码不一致"""
        # 预期结果
        excepted = {"code": 0, "msg": "两次密码不一致"}
        # 参数：data
        data = ('python1', '123456', '1234567')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        # 比对预期结果，和实际结果是否一致
        self.assertEqual(excepted, res)

    def test_user_register(self):
        """账号已经被注册"""
        # 预期结果
        excepted = {"code": 0, "msg": "该账号已存在"}
        # 参数：data
        data = ('python23', '1234567', '1234567')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        # 比对预期结果，和实际结果是否一致
        self.assertEqual(excepted, res)

    def test_password_lt6(self):
        """密码小于6"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = ('python3', '12345', '12345')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        # 比对预期结果，和实际结果是否一致
        self.assertEqual(excepted, res)

    def test_password_gt18(self):
        """密码大于18"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = ('python3', '8888888888888888888', '8888888888888888888')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        try:
            # 比对预期结果，和实际结果是否一致
            self.assertEqual(excepted, res)
        except AssertionError as e:
            print('该用例测试未通过')
            raise e
        else:
            print('该用命测试通过')

    def test_user_lt6(self):
        """账号长度小于6"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = ('py01', '1234567', '1234567')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        # 比对预期结果，和实际结果是否一致
        self.assertEqual(excepted, res)

    def test_user_gt18(self):
        """账号长度大于18"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = ('pythonpytheon2342455322q2223', '1234567', '1234567')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        try:
            # 比对预期结果，和实际结果是否一致
            self.assertEqual(excepted, res)
        except AssertionError as e:
            print('该用例测试未通过')
            raise e
        else:
            print('该用例测试通过')

    def test_user_is_none(self):
        """账号为空"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = (None, '1234567', '1234567')
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        try:
            # 比对预期结果，和实际结果是否一致
            self.assertEqual(excepted, res)
        except AssertionError as e:
            print('该用例测试未通过')
            raise e
        else:
            print('该用例测试通过')

    def test_password_is_none(self):
        """密码为空"""
        # 预期结果
        excepted = {"code": 0, "msg": "账号和密码必须在6-18位之间"}
        # 参数：data
        data = ('python56', None, None)
        # 调用被测试的功能函数，传入参数，获取实际结果
        res = register(*data)
        try:
            # 比对预期结果，和实际结果是否一致
            self.assertEqual(excepted, res)
        except AssertionError as e:
            print('该用例测试未通过')
            raise e
        else:
            print('该用例测试通过')
           

第四个文件：HTMLTestRunnerNew.py

得到测试报告：