class TestIHRMLoginParams(unittest.TestCase):
# 进行初始化
def setUp(self):
self.login_api = LoginApi()
# 定义登录数据文件的路径
filepath = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filepath))
# 编写登录成功函数
def test01_login(
self,
case_name,
request_body,
success,
code,
message,
http_code,
):
# 使用封装的接口调用登录接口，并接收返回的响应数据
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
# 打印响应数据
logging.info("登录的结果为：{}".format(response.json()))
assert_common(self, http_code, success, code, message, response)
class TestIHRMLogin(unittest.TestCase):
# 初始化
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net" + "/api/sys/login"
from api.login_api import TestLoginApi
self.login_api = TestLoginApi()
def tearDown(self):
pass
filename = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filename))
# 编写第一个案例，测试登录成功
def test01_login(abc, case_name, jsonData, http_code, success, code,
message):
# 定义请求头
headers = {"Content-Type": "application/json"}
jsonData = jsonData
# 发送登录请求
response = abc.login_api.login(jsonData, headers)
# 打印登陆的结果
result = response.json()
logging.info("登录的结果为：{}".format(result))
# 断言
assert_common(http_code, success, code, message, response, abc)
class TestLogin(unittest.TestCase):
# 初始化测试类
def setUp(self) -> None:
# 实例化LoginApi登录的接口
self.login_api = LoginApi()
def tearDown(self) -> None:
...
# 定义要加载的登录数据的路径
filename = app.base_dir + '/data/login.json'
# 编写测试函数
# 登陆成功
@parameterized.expand(read_login_data(filename))
def test01_login(self, case_name, jsonData, http_code, success, code,
message):
# 定义登陆成功所需要的请求体
jsonData = jsonData
# 利用封装的登录请求接口，发送登录请求，测试ihrm系统
response = self.login_api.login(jsonData, app.headers)
# 利用日志模块打印登陆结果（首先要导入日志模块）
logging.info("登录的结果为：{}".format(response.json()))
# 导入封装通用断言的函数
assert_common_uitls(self, response, http_code, success, code, message)
class TestLogin(unittest.TestCase):
"""登录测试类"""
@classmethod
def setUpClass(cls) -> None:
cls.login_api = LoginApi() # 初始化登录类
@classmethod
def tearDownClass(cls) -> None:
pass
def setUp(self) -> None:
pass
def tearDown(self) -> None:
pass
@parameterized.expand(read_login_data())
def test_login(self, mobile, password, http_code, success, code, message):
"""登录测试方法"""
response = self.login_api.login(mobile, password)
json_data = response.json() # 接收返回的json数据
logging.info("登录接口返回的数据为：{}".format(json_data)) # 输出日志，只能用{}占位符
# 断言
# self.assertEqual(200, response.status_code) # 断言响应状态码
# self.assertEqual(True, json_data.get("success")) # 断言success
# self.assertEqual(10000, json_data.get("code")) # 断言code
# self.assertIn("操作成功", json_data.get("message")) # 断言message
assert_common(self, response, http_code, success, code, message)
class TestIHRMLogin(unittest.TestCase):
# 进行初始化
def setUp(self):
# 导入封装的login_api类
from api.login_api import LoginApi
# 实例化LoginApi类
self.login_api = LoginApi()
def tearDown(self):
pass
# 定位登录数据文件的路径
# "."代表当前python文件的目录，但是当前的目录是在script目录中，
# 那么请求script目录中有没有data目录和data目录下的login.json文件
# ".."代表当前目录的父级目录
filename = app.BASE_DIR + "/data/login.json"
# 使用parameterized进行参数化
@parameterized.expand(read_login_data(filename))
# 创建测试函数
def test01_login(self,casename, mobile, password, success, code):
# 使用封装的api接口完成登录操作
result = self.login_api.login(mobile,password)
# 打印登录结果
print("登录的结果为：", result.json())
# 对登录结果进行断言
self.assertEqual(success, result.json().get("success"))
self.assertEqual(code, result.json().get("code"))
class TestIHRMLogin(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.login_api = LoginApi()
def setUp(self) -> None:
pass
@classmethod
def tearDownClass(cls) -> None:
pass
def tearDown(self) -> None:
pass
@parameterized.expand(read_login_data())
def test01_login(self, mobile, password, http_code, success, code,
message):
#调用封装的登录接口
response = self.login_api.login(mobile, password)
#接收返回的json数据
jsonData = response.json()
#调试输出登录接口返回的数据，日志输出只能用作为{}占位符
logging.info("接口返回的数据为：{}".format(jsonData))
#断言
assert_common(self, response, http_code, success, code, message)
class TestHRMLLogin(unittest.TestCase):
def setUp(self) -> None:
...
@classmethod
def setUpClass(cls) -> None:
# 初始化登录类
cls.login_api = LoginApi()
def tearDown(self) -> None:
...
@classmethod
def tearDownClass(cls) -> None:
...
@parameterized.expand(read_login_data())
def test_login(self, mobile, password, http_code, success, code, message):
# 调用封装的登录接口
response = self.login_api.login(mobile, password)
# 接收返回的json数据
jsonData = response.json()
# 调式输出登录接口返回的数据
logging.info("登录接口返回的数据为：{}".format(jsonData))
# 调用的封装的json数据
assert_common(self, response, http_code, success, code, message)
class TestIHRMLogin(unittest.TestCase):
# 初始化
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net" + "/api/sys/login"
from api.login_api import TestLoginApi # 导入封装的API模块
self.login_api = TestLoginApi() # 实例化登录API
def tearDown(self):
...
# 定义数据文件的路径
filename = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filename))
# 编写第一个案例，测试登录成功
def test01_login_success(abc, case_name, jsonData, http_code, success,
code, message):
# IHRM项目可以直接发送登录请求
headers = {"Content-Type": "application/json"} # 定义请求头
jsonData = jsonData
# 发送登录请求
response = abc.login_api.login(jsonData, headers)
# 打印登录的结果cvf
result = response.json()
logging.info("登录的结果为：{}".format(result))
# # 断言登录的结果
# self.assertEqual(200, response.status_code) # 断言响应状态码
# self.assertEqual(True, result.get("success")) # 断言success
# self.assertEqual(10000, result.get("code")) # 断言code
# self.assertIn("操作成功", result.get("message")) # 断言message
# 使用封装的通用断言函数实现优化断言
assert_common(http_code, success, code, message, response, abc)
class TestIHRMLogin(unittest.TestCase):
# 初始化
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net" + "/api/sys/login"
from api.login_api import TestLoginApi # 导入封装的API模块
self.login_api = TestLoginApi() # 实例化登录API
def tearDown(self):
...
# 定义数据文件路径
filename = app.BASE_DIR + '/data/login_data.json'
# 参数化时，使用定义的数据路径传入读取数据文件的函数，进行参数化
# 编写第一个案例，测试登录成功
@parameterized.expand(read_login_data(filename))
def test01_login(abc, case_name, jsonData, http_code, success, code,
message):
# 发送登录请求
headers = {"Content-Type": "application/json"} # 定义请求头
jsonData = jsonData
# 发送登录请求
response = abc.login_api.login(jsonData, headers)
# 打印登录的结果cvf
result = response.json()
logging.info("登录的结果为：{}".format(result))
# 使用封装的通用断言函数实现优化断言
assert_common(http_code, success, code, message, response, abc)
class TestIHRMLoginParams(unittest.TestCase):
# 进行初始化
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
# 定义登录数据文件的路径
filepath = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filepath))
# 编写登录成功函数
def test01_login_success(self, case_name, request_body, success, code,
message, http_code):
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
# 打印响应数据
logging.info("登录成功的结果为：{}".format(response.json()))
# assert_common(self,200,True,10000,"操作成功",response)
# 断言
self.assertEqual(http_code, response.status_code)
self.assertEqual(success, response.json().get("success"))
self.assertEqual(code, response.json().get("code"))
self.assertIn(message, response.json().get("message"))
class TestLogin(unittest.TestCase):
# 初始化测试类
def setUp(self):
# 实例化封装的登录接口
self.login_api = LoginApi()
def tearDown(self):
pass
# 定义要加载的登录数据的路径
filename = app.BASE_DIR + "/data/login.json"
# 编写测试函数
# 登录
@parameterized.expand(utils.read_login_data(filename))
def test01_login(self, case_name, jsonData, http_code, success, code,
message):
# 定义登陆成功的请求体
jsonData = jsonData
response = self.login_api.login(jsonData, app.HEADERS)
# logging.info("HEADERS里面的内容为：{}".format(app.HEADERS))
logging.info("登录的结果为：{}".format(response.json()))
# 断言登陆结果：响应状态码，success，code，message
utils.assert_common_utils(self, response, http_code, success, code,
message)
class TestIHRMLogin(unittest.TestCase):
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net/api/sys/login"
def tearDown(self):
pass
@parameterized.expand(read_login_data())
def test_01_login(self, case_name, request_body, message):
data = request_body
response = requests.post(url=self.login_url, json=data)
print(response.json())
self.assertIn(message, response.json().get("message"))
class TestLoginParams(unittest.TestCase):
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
@parameterized.expand(
read_login_data(filepath=app.BASE_DIR + '/data/login_data.json'))
def test_login(self, case_name, request_body, success, code, message,
http_code):
"""登录接口"""
response_login = self.login_api.login(
request_body, {'Content-Type': 'application/json'})
# 打印日志
logging.info('测试用例《{}》的结果为：{}'.format(case_name,
response_login.json()))
assert_common(self, http_code, success, code, message, response_login)
class TestLogin(unittest.TestCase):
# 初始化
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
# 创建登录的测试函数
@parameterized.expand(read_login_data())
def test01_login(self,mobile,password,http_code,success,code,message):
# 调用登录接口
response1 = self.login_api.login(mobile,password)
# 打印结果
logging.info("参数化登录结果为:{}".format(response1))
# 断言登录结果
assert_common_utils(self,response1,http_code,success,code,message)
class TestLoginParams(unittest.TestCase):
@classmethod
def setUpClass(cls):
# 实例化api
cls.login_api = LoginApi()
login_file_path = app.BASE_DIR + "/data/login.json"
@parameterized.expand(read_login_data(login_file_path))
# 创建测试函数
def test01_login(self,case_name, request_body, success, code, message, status_code):
# 使用实例化的login_api发送登陆接口请求
response = self.login_api.login(request_body)
# 打印登陆的数据
print(case_name)
print("登陆结果为：", response.json())
# 断言
assert_common_util(self, response, status_code, success, code, message)
class TestIHRMLogin(unittest.TestCase):
# 初始化unittest
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net/api/sys/login"
def tearDown(self):
pass
@parameterized.expand(read_login_data())
# 编写测试函数
def test01_login(self, case_name, request_body, message):
# 发要送的请求体数据
data = request_body
# 发送请求并接收结果
response = requests.post(url=self.login_url, json=data)
# 打印结果
print(response.json())
# 断言
self.assertIn(message, response.json().get('message'))
class TestIHRMLogin(unittest.TestCase):
def setUp(self):
self.logging = init_logging()
self.login_api = LoginApi()
def tearDown(self):
pass
# 定义登录数据文件的路径
filepath = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filepath))
def test01_login(self, case_name, request_body, success, code, message,
http_code):
# 使用封装的接口调用登录接口,并接受返回的响应数据
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
logging.info("%s结果为:{}".format(response.json()) % case_name)
assert_common(self, http_code, success, code, message, response)
class TestIHRMLogin(unittest.TestCase):
# 进行实例化
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
filepath = app.BASE_DIR + "/data/login_data.json"
# 编写登陆的函数
@parameterized.expand(read_login_data(filepath))
def test01_login(self, case_name, request_body, success, code, message,
hettp_code):
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
# 打印响应数据
logging.info("登录的结果：{}".format(response.json()))
# 断言
assert_common(self, hettp_code, success, code, message, response)
class TestLogin(unittest.TestCase):
# 初始化测试类
def setUp(self):
# 实例化封装的登录接口
self.login_api = LoginApi()
def tearDown(self):
pass
# 定义要加载的登录数据的路径
filename = app.BASE_DIR + "/data/login.json"
@parameterized.expand(read_login_data(filename))
def test01_login(self, case_name, jsonData, http_code, success, code,
message):
# 利用封装的登录接口，发送登录请求，测试ihrm系统
response = self.login_api.login(jsonData, app.HEADERS)
# 利用日志模块打印登录的结果（首先要导入日志模块)
logging.info("登录的结果为：{}".format(response.json()))
# 断言
assert_common_utils(self, response, http_code, success, code, message)
class UnittestTestIHRM(unittest.TestCase):
# 初始化
def setUp(self):
self.login_url = "http://ihrm-test.itheima.net/api/sys/login"
# 销毁
def tearDown(self):
pass
@parameterized.expand(read_login_data())
# 定义测试函数
def test01_login(self, case_name, request_body, message):
# 准备请求数据
data = request_body
# 发送请求并接受结果
response = requests.post(url=self.login_url, json=data)
# 打印结果
print(response.json())
# 断言
self.assertIn(message, response.json().get("message"))
class TestIHRMLogin(unittest.TestCase):
# 进行初始化
def setUp(self) -> None:
self.login_api = LoginApi()
def tearDown(self) -> None:
pass
# 创建测试方法
filename = BASE_DIR + '/data/login.json'
@parameterized.expand(read_login_data(filename=filename))
def test01_login(self, mobile, password, success, code):
#使用requests模块发送登录接口请求
response = self.login_api.login(mobile, password)
# 打印登录结果
print('登录结果为:', response.json())
# 对登录结果进行断言
self.assertEqual(success, response.json().get('success'))
self.assertEqual(code, response.json().get('code'))
class TestIHRMLogin(unittest.TestCase):
# 进行初始化
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
# 创建测试函数
filename = BASE_DIR + "/data/login.json"
@parameterized.expand(read_login_data(filename))
def test01_login(self, casename, mobile, password, success, code, message):
# 使用封装的api登录接口登录
reque = self.login_api.login(mobile, password)
# 打印登录结果
print("登陆的结果", reque.json())
# 对登录结果进行断言
# self.assertEqual(success,code,message)
self.assertEqual(success, reque.json().get("success"))
self.assertEqual(code, reque.json().get("code"))
self.assertEqual(message, reque.json().get("message"))
class TestLogin(unittest.TestCase):
# 初始化测试类
def setUp(self):
# 实例化登录接口
self.login_api = LoginApi()
def tearDown(self):
pass
# 编写测试的函数
# 登陆成功
filename = app.BASE_DIR + "/data/login.json"
@parameterized.expand(read_login_data(filename))
def test01_login_success(self,casename, jsonData, http_code, success, code, message):
# 定义请求体
jsonData = jsonData
# 利用封装的登录接口，发送登录请求
response = self.login_api.login(jsonData, app.HEADERS)
# 利用日志模块打印登录结果
logging.info("{}_响应体数据为：{}".format(casename, response.json()))
# 断言登录的结果：响应状态码、success、code、message的值
assert_commen_utils(self, response, http_code, success, code, message)
class TestLogin(unittest.TestCase):
# 初始化测试类
def setUp(self):
# 实例化loginApi
self.login_api = loginApi()
def tearDown(self):
pass
# 定义要加载的登录数据
filename = app.BASE_PATH + "/data/login.json"
# 编写测试函数
# 登陆成功
@parameterized.expand(read_login_data(filename))
def test_login(self, case_name, jsonData, http_code, success, code,
message):
jsonData = jsonData
response = self.login_api.login(jsonData, app.HEADERS)
# 利用日志模块打印登录结果(首先要导入日志模块)
logging.info("登陆的结果为:{}".format(response.json()))
# 向assert_commit_utils()函数中传递数据
assert_commit_utils(self, response, http_code, success, code, message)
class TestIhrmLogin(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.login_api = LoginApi()
@parameterized.expand(read_login_data())
def test01_login_success(self, case_data, mobile, password, http_code,
success, code, message):
# 发出请求
response = self.login_api.login(mobile, password)
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("登陆成功接口返回数据为:{}".format(jsonData))
common_assert(self, response, http_code, success, code, message)
@parameterized.expand(read_login_data())
def test02_login_no_username(self, case_data, mobile, password, http_code,
success, code, message):
response = self.login_api.login(mobile, password)
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("用户名为空返回数据为:{}".format(jsonData))
common_assert(self, response, http_code, success, code, message)
@parameterized.expand(read_login_data())
def test03_login_no_password(self, case_data, mobile, password, http_code,
success, code, message):
response = self.login_api.login(mobile, password)
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("密码为空返回数据为:{}".format(jsonData))
common_assert(self, response, http_code, success, code, message)
def test04_login_noparams_username(self):
response = self.login_api.login_parms(password="******")
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("缺少用户名参数返回数据为:{}".format(jsonData))
common_assert(self, response, 200, False, 20001, "用户名或密码错误")
def test05_login_noparams_password(self):
response = self.login_api.login_parms(mobile="13800000002")
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("缺少密码参数返回数据为:{}".format(jsonData))
common_assert(self, response, 200, False, 20001, "用户名或密码错误")
def test06_login_wrongparams_mobile(self):
response = self.login_api.login_parms(mobe="13800000002",
password="******")
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("参数错误返回的结果为:{}".format(jsonData))
common_assert(self, response, 200, False, 20001, "用户名或密码错误")
def test07_login_wrong_mobile(self):
response = self.login_api.login("13806600002", "123456")
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("用户名错误返回数据为:{}".format(jsonData))
common_assert(self, response, 200, False, 20001, "用户名或密码错误")
def test08_login_wrong_password(self):
response = self.login_api.login("13800000002", "122333")
# 接收返回的json数据
jsonData = response.json()
# 调试输出登陆接口返回的数据
logging.info("密码错误返回数据为:{}".format(jsonData))
common_assert(self, response, 200, False, 20001, "用户名或密码错误")
#多参数
def test09_login_add_parms(self):
response = self.login_api.login_parms2({
"mobile": "13800000002",
"password": "******",
"add": "7788"
})
logging.info("多参的返回数据:{}".format(response.json()))
common_assert(self, response, 200, True, 10000, "操作成功！")
class TestLogin(unittest.TestCase):
# 定义类的初始化fixture
@classmethod
def setUpClass(cls):
# 实例化封装的登录接口
cls.login_api = LoginApi()
# 定义类的销毁fixture
@classmethod
def tearDownClass(cls):
pass
# 定义登录登录数据文件的路径
file_path = app.BASE_DIR + "/data/login.json"
# 实现登录参数化
@parameterized.expand(read_login_data(file_path))
# 定义测试登录的测试用例方法
# 定义登录成功测试用例
# def test01_login_success(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "13800000002", "password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("登录成功的结果为: {}" .format(response.json()))
# # 断言
# # self.assertEqual(200, response.status_code)
# # self.assertEqual("True", response.json().get("success"))
# # self.assertEqual(10000, response.json().get("code"))
# # self.assertEqual("操作成功", response.json().get("message"))
#
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, True, 10000, "操作成功", response)
#
# # 定义手机号码为空(bug)
# def test02_mobile_is_empty(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "", "password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("手机号码为空的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 定义手机号码不存在
# def test03_mobile_not_exist(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "17564324673", "password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("手机号码不存在的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 密码错误
# def test04_error_password(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "13800000002", "password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("密码错误的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 密码为空
# def test04_password_is_empty(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "13800000002", "password": ""},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("密码为空的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 无参
# def test05_parameter_is_none(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("无参的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 传入null
# def test06_null(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(None,
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("传入None的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 99999, "抱歉，系统繁忙，请稍后重试！", response)
#
# # 多参
# def test07_more_param(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "13800000002", "password": "******", "extras_params":"1"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("传入多参的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, True, 10000, "操作成功", response)
#
# # 少参 - 缺少mobile
# def test08_less_param_mobile(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("缺少mobile的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 少参 - 缺少password
# def test08_less_param_password(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"mobile": "13800000002"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("缺少password的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 错误参数
# def test09_error_param(self):
# # 调用封装好的登录接口中获取登录接口的方法,并返回登录结果
# response = self.login_api.login(json={"molibe": "13800000002", "password": "******"},
# headers={"Content-Type": "Application/json"})
# # 用logging打印返回的结果数据
# logging.info("错误参数的结果为: {}".format(response.json()))
# # 调用utils中定义的通用断言函数
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
def test01_login(self, case_name, request_body, success, code, message,
http_code):
# 使用封装的登录接口发送请求
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
# 打印响应数据
logging.info("登录的结果为：{}".format(response.json()))
# 断言
assert_common(self, http_code, success, code, message, response)
class TestIHRMLogin(unittest.TestCase):
# 进行初始化
def setUp(self):
self.login_api = LoginApi()
def tearDown(self):
pass
# # 编写登录成功函数
# def test01_login_success(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile":"13800000002","password":"******"},
# {"Content-Type":"application/json"})
# # 打印响应数据
# logging.info("登录成功的结果为：{}".format(response.json()))
# # 断言
# # self.assertEqual(200, response.status_code)
# # self.assertEqual(True, response.json().get("success"))
# # self.assertEqual(10000, response.json().get("code"))
# # self.assertIn("操作成功", response.json().get("message"))
# assert_common(self, 200, True, 10000, "操作成功", response)
#
#
# # 实现手机号码为空
# def test02_mobile_is_empty(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "", "password": "******"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("手机号码为空的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 手机号码不存在
# def test03_mobile_is_not_exists(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "13900000002", "password": "******"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("手机号码不存在的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 密码错误
# def test04_password_is_error(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "13800000002", "password": "******"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("密码错误的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 无参
# def test05_params_is_none(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({}, {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("无参的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 传入Null
# def test06_params_is_null(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login(None, {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("传入None的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 99999, "抱歉，系统繁忙，请稍后重试！", response)
#
# # 多参
# def test07_more_params(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "13800000002", "password": "******", "more_params": "1"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("多参的结果为：{}".format(response.json()))
# assert_common(self, 200, True, 10000, "操作成功", response)
#
# # 少参-缺少mobile
# def test08_less_params_mobile(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"password": "******", "more_params": "1"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("少参-缺少mobile的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 少参-缺少Passowrd
# def test09_less_password(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "13800000002", "more_params": "1"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("少参-缺少Passowrd的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 错误参数
# def test10_params_is_error(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mboile": "13800000002", "password": "******", "more_params": "1"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("错误参数的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
#
# # 密码为空
# def test11_password_is_empty(self):
# # 使用封装的接口调用登录接口，并接收返回的响应数据
# response = self.login_api.login({"mobile": "13800000002", "password": "", "more_params": "1"},
# {"Content-Type": "application/json"})
# # 打印响应数据
# logging.info("密码为空的结果为：{}".format(response.json()))
# assert_common(self, 200, False, 20001, "用户名或密码错误", response)
# 定义登录数据文件的路径
filepath = app.BASE_DIR + "/data/login.json"
@parameterized.expand(read_login_data(filepath))
# 编写登录成功函数
def test01_login(self,case_name, request_body, success,code,message,http_code):
# 使用封装的接口调用登录接口，并接收返回的响应数据
response = self.login_api.login(request_body,
{"Content-Type": "application/json"})
# 打印响应数据s
logging.info("登录的结果为：{}".format(response.json()))
assert_common(self, http_code, success, code, message, response)
class TestIHRMEmployeeParams02(unittest.TestCase):
# 初始化unittest的函数
def setUp(self):
# 实例化登录
self.login_api = LoginApi()
# 实例化部门
self.emp_api = DepartmentApi()
def tearDown(self):
pass
# 定义登录数据文件的路径
filepath = app.BASE_DIR + "/data/login_data.json"
@parameterized.expand(read_login_data(filepath))
# 实现登录成功的接口
def test01_login_success(self, case_name, request_body, success, code, message, http_code):
# 使用封装的接口调用登录接口，并接收返回的响应数据
response = self.login_api.login(request_body, {"Content-Type": "application/json"})
# 打印响应数据
logging.info("登录的结果为：{}".format(response.json()))
# 提取登录返回的令牌
token = 'Bearer ' + response.json().get('data')
# 把令牌拼接成HEADERS并保存到全局变量HEADERS，供后续增删改查调用
app.HEADERS = {"Content-Type": "application/json", "Authorization": token}
# 打印请求头
logging.info("保存到全局变量中的请求头为：{}".format(app.HEADERS))
# 断言
assert_common(self, http_code, success, code, message, response)
# 定义部门模块的文件路径
emp_filepath = app.BASE_DIR + "/data/emp_data002.json"
# 参数化
@parameterized.expand(read_emp_data(emp_filepath))
def test02_add_emp(self, a, b, c, d, e, f, g, h, i, j, k, l, m):
# 发送添加部门的接口请求
response = self.emp_api.add_emp(a, b, c, d, app.HEADERS)
# 打印添加部门的结果
logging.info("添加部门的结果为：{}".format(response.json()))
# 提取部门中的令牌并把部门令牌保存到全局变量中
app.EMP_ID = response.json().get("data").get("id")
# 打印保存的部门ID
logging.info("保存到全局变量的部门的ID为：{}".format(app.EMP_ID))
# 断言
assert_common(self, h, e, f, g, response)
# 发送查询部门的接口请求:
response = self.emp_api.query_emp(app.EMP_ID, app.HEADERS)
# 打印查询部门的数据
logging.info("查询部门的结果为：{}".format(response.json()))
# 断言
assert_common(self, h, e, f, g, response)
# 调用封装的修改部门接口，发送接口请求
response = self.emp_api.modify_emp(m, i, j, k, l, app.HEADERS)
# 打印数据
logging.info("修改部门的结果为：{}".format(response.json()))
# 断言
assert_common(self, 200, False, 99999, "抱歉，系统繁忙，请稍后重试！", response)
# 调用封装的删除部门接口哦，发送接口请求
response = self.emp_api.delete_emp(m, app.HEADERS)
# 打印删除员工的结果为
logging.info("删除部门的结果为：{}".format(response.json()))
# 断言
assert_common(self, 200, False, 99999, "抱歉，系统繁忙，请稍后重试！", response)
