devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python接口自动化测试-篇1(postman+requests+pytest+allure)_python postman

作者：小小林熬夜学编程 | 2024-05-25 03:26:50

赞

踩

python postman

Python接口自动化测试是一种使用Python编程语言来编写脚本以自动执行针对应用程序接口（APIs）的测试过程。这种测试方法专注于检查系统的不同组件或服务之间的交互，确保它们按照预期规范进行通信，而不涉及用户界面（UI）的验证。

目录

一、接口测试基础

二、工具实现接口测试

2.1、postman接口测试

2.2、postman自动关联

2.3、postman批量执行

2.4、登录单接口测试

2.5、postman断言

2.6、postman参数化

2.7、课程增删改查测试

三、代码实现接口测试

2.1、图片验证码获取及登录自动化

2.2、课程新增代码自动化

2.3、合同上传与新增接口自动化

2.4、登录单接口自动化测试

2.5、登录单接口自动化-数据驱动实现

2.6、课程添加自动化

2.7、课程查询接口自动化

2.8、课程修改接口自动化

2.9、课程删除接口自动化

2.10、项目配置文件config

2.11、allure生成测试报告

一、接口测试基础

URL的组成=协议+服务器地址+端口号+资源路径+参数

Http请求：请求行+请求头+请求体

请求行=请求类型+资源地址+版本协议

请求头(键值对类型)=请求数据类型等

请求体=请求的数据，一般使用Json类型

Http响应：状态行+响应头

状态行=协议版本号+响应状态码+响应状态说明

响应头=响应服务器+响应时间+响应类型+响应内容长度

响应体=响应的内容，一般是json串的形式

二、工具实现接口测试

2.1、postman接口测试

1.使用postman发送GET请求：查询uuid

2.使用postman发送POST请求：根据uuid进行登录请求

2.2、postman自动关联

有多个接口请求，需要将一个接口的返回的结果保存为变量，另外一个接口请求的时候使用保存变量。

1.首先创建一个环境变量：并命名为FAT。

2.在第一个接口中设置环境变量，并将第一个接口请求的参数设置到环境变量中去。

3.在第二个接口的请求参数中直接动态引用从第一个接口中获取的动态变量值。

4.在登录接口中获取响应得到的token，存储为环境变量。

5.在新增课程的接口中，引用登录接口存储的token变量。

6.合同上传接口，需要获取登录接口保存的token环境变量。

7.在合同上传接口的请求体里设置待上传的合同文件。

8.需要在合同上传接口中将响应得到的fileName字段保存为环境变量。

9.在添加合同接口中使用{{fileName}}引用合同上传接口中保存的环境变量。

10.通过手机号查询合同信息。

2.3、postman批量执行

在接口自动化测试文件夹中选择run，然后点击如下箭头所示的Run自动化测试即可实现接口的批量执行。

2.4、登录单接口测试

1.可以创建一个文件夹，在文件夹下建立测试用例请求，进行一个接口的所有用例的测试。

2.5、postman断言

可以在postman中设置断言，Tests中断言函数，通过断言函数对响应结果进行断言。

2.6、postman参数化

设置文件并加载，然后使用动态参数{{变量名}}获取文件中的字段。

2.7、课程增删改查测试

由于增删改查的思路都是一致的，设置请求url，请求头以及请求体即可完成测试，在一个课程添加文件夹下可以测试与管理多个用例。

三、代码实现接口测试

接口自动化测试流程：1.选取自动化测试用例 2.搭建自动化测试环境 3.搭建自动化测试框架 4.代码实现自动化 5.输出测试报告 6.实现持续集成

核心技术：python语言+pytest框架+requests框架

自动化测试框架的目录结构：

2.1、图片验证码获取及登录自动化

第一步，获取图片验证码：

  1. # 获取图片验证码
  2.  
  3. # 1.导包
  4. import requests
  5.  
  6. # 2.发送请求
  7. response = requests.get(url="http://kdtx-test.itheima.net/api/captchaImage")
  8.  
  9. # 3.查看响应
  10. print(response.status_code)
  11. print(response.text)

第二步：根据获取的验证码uuid发送登录请求

  1. # 登录
  2.  
  3. # 1.导包
  4. import requests
  5.  
  6. # 2.发送请求
  7. url = "http://kdtx-test.itheima.net/api/login"
  8. header_data = {
  9.     "Content-Type": "application/json"
  10. }
  11. login_data = {
  12.     "username": "admin",
  13.     "password": "HM_2023_test",
  14.     "code": "2",
  15.     "uuid": "98648849e1214e67bd7c9d4af396ab69"
  16. }
  17. try:
  18.    response = requests.post(url=url,headers=header_data,json=login_data)
  19. except Exception as e:
  20.     print("异常：", e)
  21. finally:
  22.     pass
  23.  
  24. # 3.获取响应结果
  25. print(response.status_code)
  26. print(response.json())

上述的代码并没有合理的实现api的封装与调用，下面将登录过程封装到api包下的loginAPI类中，再后续的测试中直接实例化登录类，并调用相应的方法即可实现登录。

  1. # 依据接口文档，封接口信息，需要使用的测试数据从测试用例传递
  2. # 接口方法被调用需要返回对应的响应结果
  3.  
  4. # 1.导包
  5. import requests
  6. # 2.创建接口类
  7. class loginAPI:
  8.   # 初始化
  9.   def __init__(self):
  10.       # 指定url
  11.       self.url_verify = "http://kdtx-test.itheima.net/api/captchaImage"
  12.       self.url_login = "http://kdtx-test.itheima.net/api/login"
  13.  
  14.   # 验证码
  15.   def get_verify_code(self):
  16.       return requests.get(url=self.url_verify)
  17.  
  18.   # 登录
  19.   def login(self, test_data):
  20.       return requests.post(self.url_login, json=test_data)

在具体的测试类中调用封装的api进行获取验证码以及登录。

  1.  
  2.  
  3. # 1.导包
  4. from api.login import loginAPI
  5.  
  6. # 2.创建测试类
  7. class TestContractBusiness:
  8.     # 2.1 前置处理
  9.     def setup(self):
  10.         # 实例化接口对象
  11.         self.login_api = loginAPI()
  12.  
  13.     # 2.2 后置处理
  14.     def teardown(self):
  15.         pass
  16.  
  17.     # 01.登录成功
  18.     def test01_login_success(self):
  19.         # 获取验证码
  20.         res_first = self.login_api.get_verify_code()
  21.         print(res_first.status_code)
  22.         print(res_first.json())
  23.  
  24.         # 登录
  25.         login_data = {
  26.             "username": "admin",
  27.             "password": "HM_2023_test",
  28.             "code": "2",
  29.             "uuid": res_first.json().get("uuid")
  30.         }
  31.         res_second = self.login_api.login(login_data)
  32.         print(res_second.status_code)
  33.         print(res_second.json())
  34.  
  35.  
  36. if __name__ == '__main__':
  37.     test = TestContractBusiness()
  38.     test.setup()
  39.     test.test01_login_success()
2.2、课程新增代码自动化

首先封装课程新增接口类。

  1. # 课程接口的封装
  2.  
  3. # 导包
  4. import requests
  5.  
  6. # 创建接口类
  7. class courseAPI:
  8.     # 初始化
  9.     def __init__(self):
  10.         self.add_course_url = "http://kdtx-test.itheima.net/api/clues/course/"
  11.  
  12.     # 课程添加
  13.     def add_course(self, test_data, token):
  14.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})

然后在测试类中，定义课程新增测试方法。

  1.  
  2.  
  3. # 1.导包
  4. from api.login import loginAPI
  5. from api.course import courseAPI
  6.  
  7. # 2.创建测试类
  8. class TestContractBusiness:
  9.     # 2.1 前置处理
  10.     def setup(self):
  11.         # 实例化接口对象
  12.         self.login_api = loginAPI()
  13.         self.course_api = courseAPI()
  14.         self.token = None
  15.  
  16.     # 2.2 后置处理
  17.     def teardown(self):
  18.         pass
  19.  
  20.     # 01.登录成功
  21.     def test01_login_success(self):
  22.         # 获取验证码
  23.         res_first = self.login_api.get_verify_code()
  24.         print(res_first.status_code)
  25.         print(res_first.json())
  26.  
  27.         # 登录
  28.         login_data = {
  29.             "username": "admin",
  30.             "password": "HM_2023_test",
  31.             "code": "2",
  32.             "uuid": res_first.json().get("uuid")
  33.         }
  34.         res_second = self.login_api.login(login_data)
  35.         print(res_second.status_code)
  36.         print(res_second.json())
  37.         TestContractBusiness.token = res_second.json().get("token")
  38.  
  39.  
  40.     # 新增课程成功
  41.     def test02_add_course(self):
  42.         add_data = {
  43.             "name": "测试开发课程",
  44.             "subject": "6",
  45.             "price": "344",
  46.             "applicablePerson": "2"
  47.         }
  48.         res_third = self.course_api.add_course(test_data=add_data, token=TestContractBusiness.token)
  49.         print(res_third.status_code)
  50.         print(res_third.json())
  51.  
  52. if __name__ == '__main__':
  53.     test = TestContractBusiness()
  54.     test.setup()
  55.     test.test01_login_success()
  56.     test.test02_add_course()
2.3、合同上传与新增接口自动化

首先封装合同上传与新增接口，如下：

  1.  
  2. # 1.导包
  3. import requests
  4.  
  5. # 2.定义合同接口类
  6. class ContractAPI:
  7.     # 初始化
  8.     def __init__(self):
  9.         self.url_upload = "http://kdtx-test.itheima.net/api/common/upload"
  10.         self.add_contract_url = "http://kdtx-test.itheima.net/api/contract"
  11.  
  12.     # 合同上传接口
  13.     def upload_abstract(self, test_data, token):
  14.         return requests.post(url=self.url_upload, files={"file": test_data}, headers={"Authorization": token})
  15.  
  16.     # 合同新增接口
  17.     def add_abstract(self, test_data, token):
  18.         return requests.post(url=self.add_contract_url, json=test_data, headers={"Authorization": token})

编写合同上传和合同新增测试脚本：
 

  1.  
  2.  
  3. # 1.导包
  4. from api.login import LoginAPI
  5. from api.course import CourseAPI
  6. from api.contract import ContractAPI
  7.  
  8. # 2.创建测试类
  9. class TestContractBusiness:
  10.     # 2.1 前置处理
  11.  
  12.     token = None
  13.     file_name = None
  14.  
  15.     def setup(self):
  16.         # 实例化接口对象
  17.         self.login_api = LoginAPI()
  18.         self.course_api = CourseAPI()
  19.         self.contract_api = ContractAPI()
  20.  
  21.  
  22.     # 2.2 后置处理
  23.     def teardown(self):
  24.         pass
  25.  
  26.     # 01.登录成功
  27.     def test01_login_success(self):
  28.         # 获取验证码
  29.         res_first = self.login_api.get_verify_code()
  30.         print(res_first.status_code)
  31.         print(res_first.json())
  32.  
  33.         # 登录
  34.         login_data = {
  35.             "username": "admin",
  36.             "password": "HM_2023_test",
  37.             "code": "2",
  38.             "uuid": res_first.json().get("uuid")
  39.         }
  40.         res_second = self.login_api.login(login_data)
  41.         print(res_second.status_code)
  42.         print(res_second.json())
  43.         TestContractBusiness.token = res_second.json().get("token")
  44.  
  45.  
  46.     # 02.新增课程成功
  47.     def test02_add_course(self):
  48.         add_data = {
  49.             "name": "测试开发课程1",
  50.             "subject": "6",
  51.             "price": "344",
  52.             "applicablePerson": "2"
  53.         }
  54.         res_third = self.course_api.add_course(test_data=add_data, token=TestContractBusiness.token)
  55.         print(res_third.status_code)
  56.         print(res_third.json())
  57.  
  58.     # 03.合同上传接口
  59.     def test03_upload_abstract(self):
  60.         file = open("../data/test_file.txt", "rb")
  61.         response = self.contract_api.upload_abstract(test_data=file, token=TestContractBusiness.token)
  62.         print(response.status_code)
  63.         print(response.json())
  64.         TestContractBusiness.file_name = response.json().get("fileName")
  65.  
  66.     # 04.合同新增接口
  67.     def test04_add_abstract(self):
  68.         add_data = {
  69.            "name": "测试",
  70.            "phone": "13827648970",
  71.            "contractNo": "HT20240ww3",
  72.            "subject": "6",
  73.            "courseId": "99",
  74.            "channel": "0",
  75.            "activityId" : 77,
  76.            "fileName": TestContractBusiness.file_name
  77.         }
  78.         response = self.contract_api.add_abstract(test_data=add_data, token=TestContractBusiness.token)
  79.         print(response.status_code)
  80.         print(response.json())
  81.  
  82. if __name__ == '__main__':
  83.     test = TestContractBusiness()
  84.     test.setup()
  85.     test.test01_login_success()
  86.     test.test02_add_course()
  87.     test.test03_upload_abstract()
  88.     test.test04_add_abstract()

2.4、登录单接口自动化测试

首先封装获取验证码与登录接口。

  1. # 依据接口文档，封接口信息，需要使用的测试数据从测试用例传递
  2. # 接口方法被调用需要返回对应的响应结果
  3.  
  4. # 1.导包
  5. import requests
  6. # 2.创建接口类
  7. class LoginAPI:
  8.   # 初始化
  9.   def __init__(self):
  10.       # 指定url
  11.       self.url_verify = "http://kdtx-test.itheima.net/api/captchaImage"
  12.       self.url_login = "http://kdtx-test.itheima.net/api/login"
  13.  
  14.   # 验证码
  15.   def get_verify_code(self):
  16.       return requests.get(url=self.url_verify)
  17.  
  18.   # 登录
  19.   def login(self, test_data):
  20.       return requests.post(self.url_login, json=test_data)

编写等于测试用例脚本，并对响应结果做校验。

  1.  
  2. # 1.导包
  3. from api.login import LoginAPI
  4.  
  5. # 2.创建测试类
  6. class TestLoginAPI:
  7.     uuid = None
  8.     # 前置处理
  9.     def setup(self):
  10.        # 实例化
  11.        self.login_api = LoginAPI()
  12.        # 获取验证码
  13.        response = self.login_api.get_verify_code()
  14.        # 获取验证码中的uuid
  15.        TestLoginAPI.uuid = response.json().get("uuid")
  16.     # 后置处理
  17.     def teardown(self):
  18.         pass
  19.     # 登录成功
  20.     def login_success(self):
  21.         login_data = {
  22.             "username": "admin",
  23.             "password": "HM_2023_test",
  24.             "code": "2",
  25.             "uuid": TestLoginAPI.uuid
  26.         }
  27.         response = self.login_api.login(test_data=login_data)
  28.         # 断言验证码
  29.         assert 200 == response.status_code
  30.         # 断言响应数据包含成功
  31.         assert '成功' in response.text
  32.         # 断言响应json数据中的code值
  33.         assert 200 == response.json().get("code")
  34.         # 登录成功
  35.  
  36.     # 登录失败
  37.     def login_fail(self):
  38.         login_data = {
  39.             "username": "",
  40.             "password": "HM_2023_test",
  41.             "code": "2",
  42.             "uuid": TestLoginAPI.uuid
  43.         }
  44.         response = self.login_api.login(test_data=login_data)
  45.         # 断言验证码
  46.         assert 200 == response.status_code
  47.         # 断言响应数据包含成功
  48.         assert '错误' in response.text
  49.         # 断言响应json数据中的code值
  50.         assert 500 == response.json().get("code")
  51.  
  52. if __name__ == '__main__':
  53.     test_login = TestLoginAPI()
  54.     test_login.setup()
  55.     test_login.login_success()
  56.     test_login.setup()
  57.     test_login.login_fail()
2.5、登录单接口自动化-数据驱动实现

数据驱动：以测试数据驱动脚本执行，维护焦点从脚本转向测试数据的一种自动化测试用例设计模式。

方式1：直接定义测试数据，然后使用pytest框架进行参数化，实现数据驱动。

  1.  
  2. # 1.导包
  3. from api.login import LoginAPI
  4. import pytest
  5.  
  6. # 测试数据
  7. test_data = [("admin", "HM_2023_test", 200, '成功', 200),
  8.              ("", "HM_2023_test", 200, '错误', 500)]
  9.  
  10. # 2.创建测试类
  11. class TestLoginAPI:
  12.     uuid = None
  13.     # 前置处理
  14.     def setup(self):
  15.        # 实例化
  16.        self.login_api = LoginAPI()
  17.        # 获取验证码
  18.        response = self.login_api.get_verify_code()
  19.        # 获取验证码中的uuid
  20.        TestLoginAPI.uuid = response.json().get("uuid")
  21.     # 后置处理
  22.     def teardown(self):
  23.         pass
  24.     # 登录成功
  25.     @pytest.mark.parametrize("username, password, status, message, code",  test_data)
  26.     def test_login_success(self, username, password, status, message, code):
  27.         login_data = {
  28.             "username": username,
  29.             "password": password,
  30.             "code": "2",
  31.             "uuid": TestLoginAPI.uuid
  32.         }
  33.         response = self.login_api.login(test_data=login_data)
  34.         # 断言验证码
  35.         assert status == response.status_code
  36.         # 断言响应数据包含成功
  37.         assert message in response.text
  38.         # 断言响应json数据中的code值
  39.         assert code == response.json().get("code")
  40.         # 登录成功
  41.  
  42.     # 登录失败
  43.     @pytest.mark.parametrize("username, password, status, message, code", test_data)
  44.     def test_login_fail(self,  username, password, status, message, code):
  45.         login_data = {
  46.             "username": username,
  47.             "password": password,
  48.             "code": "2",
  49.             "uuid": TestLoginAPI.uuid
  50.         }
  51.         response = self.login_api.login(test_data=login_data)
  52.         # 断言验证码
  53.         assert status == response.status_code
  54.         # 断言响应数据包含成功
  55.         assert message in response.text
  56.         # 断言响应json数据中的code值
  57.         assert code == response.json().get("code")

方式2：

首先在data文件夹定义：login.json文件用于测试数据。

  1. [
  2. {
  3.   "username": "admin",
  4.   "password": "HM_2023_test",
  5.   "status": 200,
  6.   "message": "成功",
  7.   "code": 200
  8. },
  9.   {
  10.   "username": "",
  11.   "password": "HM_2023_test",
  12.   "status": 200,
  13.   "message": "错误",
  14.   "code": 500
  15. }
  16. ]

使用pytest做参数化，完成数据驱动测试。

  1. # 1.导包
  2. from api.login import LoginAPI
  3. import pytest
  4. import json
  5.  
  6.  
  7. # 读取json文件
  8. def build_data(json_file):
  9.     # 定义空列表
  10.     test_data = []
  11.     # 打开json
  12.     with open(json_file, "r",  encoding='utf-8') as file:
  13.         # 加载json数据
  14.         json_data = json.load(file)
  15.         # 循环遍历测试数据
  16.         for case_data in json_data:
  17.             # 解析数据
  18.             username = case_data.get("username")
  19.             password = case_data.get("password")
  20.             status = case_data.get("status")
  21.             message = case_data.get("message")
  22.             code = case_data.get("code")
  23.             test_data.append((username, password, status, message, code))
  24.     return test_data
  25.  
  26.  
  27. # 2.创建测试类
  28. class TestLogin:
  29.     uuid = None
  30.  
  31.     # 前置处理
  32.     def setup(self):
  33.         # 实例化
  34.         self.login_api = LoginAPI()
  35.         # 获取验证码
  36.         response = self.login_api.get_verify_code()
  37.         # 获取验证码中的uuid
  38.         TestLogin.uuid = response.json().get("uuid")
  39.  
  40.     # 后置处理
  41.     def teardown(self):
  42.         pass
  43.  
  44.     # 登录成功
  45.     @pytest.mark.parametrize("username, password, status, message, code", build_data(json_file="../data/login.json"))
  46.     def test_login__success(self, username, password, status, message, code):
  47.         login_data = {
  48.             "username": username,
  49.             "password": password,
  50.             "code": "2",
  51.             "uuid": TestLogin.uuid
  52.         }
  53.         response = self.login_api.login(test_data=login_data)
  54.         # 断言验证码
  55.         assert status == response.status_code
  56.         # 断言响应数据包含成功
  57.         assert message in response.text
  58.         # 断言响应json数据中的code值
  59.         assert code == response.json().get("code")
  60.         # 登录成功
  61.  
  62.     # 登录失败
  63.     @pytest.mark.parametrize("username, password, status, message, code", build_data(json_file="../data/login.json"))
  64.     def test_login_fail(self, username, password, status, message, code):
  65.         login_data = {
  66.             "username": username,
  67.             "password": password,
  68.             "code": "2",
  69.             "uuid": TestLogin.uuid
  70.         }
  71.         response = self.login_api.login(test_data=login_data)
  72.         # 断言验证码
  73.         assert status == response.status_code
  74.         # 断言响应数据包含成功
  75.         assert message in response.text
  76.         # 断言响应json数据中的code值
  77.         assert code == response.json().get("code")
  78.  
  79.  
  80.

正常pychram调试的时候方法和类是没有绿色三角形的，即不能单独调试，需要自定义main函数进行实例并调用方法调试，但是可以将类与方法加载到pytest框架中即可单独调试函数和类。

但是需要注意2点：

第一：需要设置测试框架使用pytest

第二，类和方法的命名要符合pytest框架规范，pytest才能识别：

类需要以Test开头，方法需要以test_开头，另外python文件名需要以test_开头，或_test结尾

2.6、课程添加自动化

首先需要在api目录下封装登录接口与课程上传接口。

  1. # 1.导包
  2. import requests
  3. # 2.创建接口类
  4. class LoginAPI:
  5.   # 初始化
  6.   def __init__(self):
  7.       # 指定url
  8.       self.url_verify = "http://kdtx-test.itheima.net/api/captchaImage"
  9.       self.url_login = "http://kdtx-test.itheima.net/api/login"
  10.  
  11.   # 验证码
  12.   def get_verify_code(self):
  13.       return requests.get(url=self.url_verify)
  14.  
  15.   # 登录
  16.   def login(self, test_data):
  17.       return requests.post(self.url_login, json=test_data)
  1.  
  2. # 导包
  3. import requests
  4.  
  5. # 创建接口类
  6. class CourseAPI:
  7.     # 初始化
  8.     def __init__(self):
  9.         self.add_course_url = "http://kdtx-test.itheima.net/api/clues/course/"
  10.  
  11.     # 课程添加
  12.     def add_course(self, test_data, token):
  13.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})

然后编写测试脚本课程上传并断言结果。

  1.  
  2. # 导包
  3. from api.login import LoginAPI
  4. from api.course import CourseAPI
  5.  
  6. # 课程添加类
  7. class TestAddCourseAPI:
  8.  
  9.     token = None
  10.  
  11.     def setup(self):
  12.         # 初始化接口
  13.         self.api_login = LoginAPI()
  14.         self.api_course = CourseAPI()
  15.         # 获取验证码
  16.         res = self.api_login.get_verify_code()
  17.         # 登录
  18.         login_data = {
  19.             "username": "admin",
  20.             "password": "HM_2023_test",
  21.             "code": "2",
  22.             "uuid": res.json().get("uuid")
  23.         }
  24.         response = self.api_login.login(test_data=login_data)
  25.         TestAddCourseAPI.token = response.json().get("token")
  26.  
  27.     def teardown(self):
  28.         pass
  29.  
  30.     # 课程添加成功
  31.     def test_add_course_success(self):
  32.         add_data = {
  33.            "name": "测试开发课程",
  34.            "subject": "6",
  35.            "price": "344",
  36.            "applicablePerson": "2"
  37.         }
  38.         response = self.api_course.add_course(test_data=add_data, token=TestAddCourseAPI.token)
  39.         # 断言响应状态码
  40.         assert 200 == response.status_code
  41.         # 断言message
  42.         assert '成功' in response.text
  43.         # 断言code
  44.         assert 200 == response.json().get("code")

2.7、课程查询接口自动化

首先封装查询课程接口api，同时需要封装登录接口api。

  1. # 导包
  2. import requests
  3.  
  4. # 创建接口类
  5. class CourseAPI:
  6.     # 初始化
  7.     def __init__(self):
  8.         self.add_course_url = "http://kdtx-test.itheima.net/api/clues/course/"
  9.         self.select_course_url = "http://kdtx-test.itheima.net/api/clues/course/list"
  10.  
  11.     # 课程添加
  12.     def add_course(self, test_data, token):
  13.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  14.  
  15.     # 查询课程列表
  16.     def select_course(self, test_data, token):
  17.         return requests.get(url=self.select_course_url + f"{test_data}", headers={"Authorization": token})

使用pytest框架调用封装的课程查询接口实现课程查询自动化。

  1.  
  2. # 导包
  3. from api.login import LoginAPI
  4. from api.course import CourseAPI
  5.  
  6. # 课程添加类
  7. class TestAddCourseAPI:
  8.  
  9.     token = None
  10.  
  11.     def setup(self):
  12.         # 初始化接口
  13.         self.api_login = LoginAPI()
  14.         self.api_course = CourseAPI()
  15.         # 获取验证码
  16.         res = self.api_login.get_verify_code()
  17.         # 登录
  18.         login_data = {
  19.             "username": "admin",
  20.             "password": "HM_2023_test",
  21.             "code": "2",
  22.             "uuid": res.json().get("uuid")
  23.         }
  24.         response = self.api_login.login(test_data=login_data)
  25.         TestAddCourseAPI.token = response.json().get("token")
  26.  
  27.     def teardown(self):
  28.         pass
  29.  
  30.     # 课程查询成功
  31.     def test_select_course_success(self):
  32.         response = self.api_course.select_course(test_data="?name=测试开发提升课", token=TestAddCourseAPI.token)
  33.         # 断言
  34.         assert 200 == response.status_code
  35.         assert '成功' in response.text
  36.         assert 200 == response.json().get("code")
  37.     # 课程查询失败
  38.     def test_select_course_fail(self):
  39.         response = self.api_course.select_course(test_data="?name=测试开发提升课", token="***")
  40.         # 断言
  41.         assert 200 == response.status_code
  42.         assert '认证失败' in response.text
  43.         assert 401 == response.json().get("code")
2.8、课程修改接口自动化

首先在api包下先封装课程修改接口，如下：

  1. # 导包
  2. import requests
  3.  
  4. # 创建接口类
  5. class CourseAPI:
  6.     # 初始化
  7.     def __init__(self):
  8.         self.add_course_url = "http://kdtx-test.itheima.net/api/clues/course/"
  9.         self.select_course_url = "http://kdtx-test.itheima.net/api/clues/course/list"
  10.  
  11.     # 课程添加
  12.     def add_course(self, test_data, token):
  13.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  14.  
  15.     # 查询课程列表
  16.     def select_course(self, test_data, token):
  17.         return requests.get(url=self.select_course_url + f"{test_data}", headers={"Authorization": token})
  18.  
  19.     # 修改课程
  20.     def update_course(self, test_data, token):
  21.         return requests.put(url=self.add_course_url, json=test_data, headers={"Authorization": token})

在script包下编写测试脚本，测试课程修改接口：
 

  1. # 导包
  2. from api.login import LoginAPI
  3. from api.course import CourseAPI
  4.  
  5. # 课程添加类
  6. class TestUpdateCourseAPI:
  7.  
  8.     token = None
  9.  
  10.     def setup(self):
  11.         # 初始化接口
  12.         self.api_login = LoginAPI()
  13.         self.api_course = CourseAPI()
  14.         # 获取验证码
  15.         res = self.api_login.get_verify_code()
  16.         # 登录
  17.         login_data = {
  18.             "username": "admin",
  19.             "password": "HM_2023_test",
  20.             "code": "2",
  21.             "uuid": res.json().get("uuid")
  22.         }
  23.         response = self.api_login.login(test_data=login_data)
  24.         TestUpdateCourseAPI.token = response.json().get("token")
  25.  
  26.     def teardown(self):
  27.         pass
  28.  
  29.     # 课程修改成功
  30.     def test_update_course_success(self):
  31.         update_data = {
  32.             "id": "109",
  33.             "name": "测试接口001",
  34.             "subject": "6",
  35.             "price": 999,
  36.             "applicablePerson": "2",
  37.             "info": "课程介绍003"
  38.         }
  39.         response = self.api_course.update_course(test_data=update_data, token=TestUpdateCourseAPI.token)
  40.         # 断言
  41.         assert 200 == response.status_code
  42.         assert '成功' in response.text
  43.         assert 200 == response.json().get("code")
  44.     # 课程修改失败
  45.     def test_update_course_fail(self):
  46.         update_data = {
  47.             "id": "109",
  48.             "name": "测试接口001",
  49.             "subject": "6",
  50.             "price": 999,
  51.             "applicablePerson": "2",
  52.             "info": "课程介绍003"
  53.         }
  54.         response = self.api_course.update_course(test_data=update_data, token="***")
  55.         # 断言
  56.         assert 200 == response.status_code
  57.         assert '认证失败' in response.text
  58.         assert 401 == response.json().get("code")
2.9、课程删除接口自动化

首先封装删除课程的接口，具体如下：

  1. # 课程接口的封装
  2.  
  3. # 导包
  4. import requests
  5.  
  6. # 创建接口类
  7. class CourseAPI:
  8.     # 初始化
  9.     def __init__(self):
  10.         self.add_course_url = "http://kdtx-test.itheima.net/api/clues/course/"
  11.         self.select_course_url = "http://kdtx-test.itheima.net/api/clues/course/list"
  12.  
  13.     # 课程添加
  14.     def add_course(self, test_data, token):
  15.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  16.  
  17.     # 查询课程列表
  18.     def select_course(self, test_data, token):
  19.         return requests.get(url=self.select_course_url + f"{test_data}", headers={"Authorization": token})
  20.  
  21.     # 修改课程
  22.     def update_course(self, test_data, token):
  23.         return requests.put(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  24.  
  25.     # 删除课程
  26.     def delete_course(self, course_id, token):
  27.         return requests.delete(self.add_course_url + f"/{course_id}", headers={"Authorization": token})
  28.

然后编写测试脚本对课程删除接口进行测试，并断言测试结果。

  1.  
  2. # 导包
  3. from api.login import LoginAPI
  4. from api.course import CourseAPI
  5.  
  6. # 课程删除类
  7. class TestDeleteCourseAPI:
  8.  
  9.     token = None
  10.  
  11.     def setup(self):
  12.         # 初始化接口
  13.         self.api_login = LoginAPI()
  14.         self.api_course = CourseAPI()
  15.         # 获取验证码
  16.         res = self.api_login.get_verify_code()
  17.         # 登录
  18.         login_data = {
  19.             "username": "admin",
  20.             "password": "HM_2023_test",
  21.             "code": "2",
  22.             "uuid": res.json().get("uuid")
  23.         }
  24.         response = self.api_login.login(test_data=login_data)
  25.         TestDeleteCourseAPI.token = response.json().get("token")
  26.  
  27.     def teardown(self):
  28.         pass
  29.  
  30.     # 课程删除成功
  31.     def test_delete_course_success(self):
  32.         response = self.api_course.delete_course(course_id=109, token=TestDeleteCourseAPI.token)
  33.         # 断言
  34.         assert 200 == response.status_code
  35.         assert '成功' in response.text
  36.         assert 200 == response.json().get("code")
  37.  
  38.     # 课程删除失败(课程id不存在)
  39.     def test_delete_course_fail_id(self):
  40.         response = self.api_course.delete_course(course_id=1000000000, token=TestDeleteCourseAPI.token)
  41.         # 断言
  42.         assert 200 == response.status_code
  43.         assert '操作失败' in response.text
  44.         assert 500 == response.json().get("code")
  45.  
  46.     # 课程删除失败(未登录)
  47.     def test_delete_course_fail_login(self):
  48.         response = self.api_course.delete_course(course_id=110, token="***")
  49.         # 断言
  50.         assert 200 == response.status_code
  51.         assert '认证失败' in response.text
  52.         assert 401 == response.json().get("code")
  53.

2.10、项目配置文件config

在主项目的根目录下定义一个config1.py文件定义url的共用路径与当前根目录的地址。

  1. # 配置类
  2.  
  3. import os
  4.  
  5. #  设置项目环境域名
  6. BASE_URL = "http://kdtx-test.itheima.net"
  7.  
  8. # 项目根路径
  9. BASE_PATH = os.path.dirname(__file__)

接口封装类中换成BASE_URL拼接的形式。

  1. # 导包
  2. import requests
  3. import config1
  4.  
  5. # 创建接口类
  6. class CourseAPI:
  7.     # 初始化
  8.     def __init__(self):
  9.         self.add_course_url = config1.BASE_URL + "/api/clues/course/"
  10.         self.select_course_url = config1.BASE_URL + "/api/clues/course/list"
  11.  
  12.     # 课程添加
  13.     def add_course(self, test_data, token):
  14.         return requests.post(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  15.  
  16.     # 查询课程列表
  17.     def select_course(self, test_data, token):
  18.         return requests.get(url=self.select_course_url + f"{test_data}", headers={"Authorization": token})
  19.  
  20.     # 修改课程
  21.     def update_course(self, test_data, token):
  22.         return requests.put(url=self.add_course_url, json=test_data, headers={"Authorization": token})
  23.  
  24.     # 删除课程
  25.     def delete_course(self, course_id, token):
  26.         return requests.delete(self.add_course_url + f"/{course_id}", headers={"Authorization": token})

具体的路径中换成BASE_PATH拼接的形式。

  1. # 1.导包
  2. from api.login import LoginAPI
  3. import pytest
  4. import json
  5. import config1
  6.  
  7. # 读取json文件
  8. def build_data(json_file):
  9.     # 定义空列表
  10.     test_data = []
  11.     # 打开json
  12.     with open(json_file, "r",  encoding='utf-8') as file:
  13.         # 加载json数据
  14.         json_data = json.load(file)
  15.         # 循环遍历测试数据
  16.         for case_data in json_data:
  17.             # 解析数据
  18.             username = case_data.get("username")
  19.             password = case_data.get("password")
  20.             status = case_data.get("status")
  21.             message = case_data.get("message")
  22.             code = case_data.get("code")
  23.             test_data.append((username, password, status, message, code))
  24.     return test_data
  25.  
  26.  
  27. # 2.创建测试类
  28. class TestLogin:
  29.     uuid = None
  30.  
  31.     # 前置处理
  32.     def setup(self):
  33.         # 实例化
  34.         self.login_api = LoginAPI()
  35.         # 获取验证码
  36.         response = self.login_api.get_verify_code()
  37.         # 获取验证码中的uuid
  38.         TestLogin.uuid = response.json().get("uuid")
  39.  
  40.     # 后置处理
  41.     def teardown(self):
  42.         pass
  43.  
  44.     # 登录成功
  45.     @pytest.mark.parametrize("username, password, status, message, code", build_data(json_file=config1.BASE_PATH + "/data/login.json"))
  46.     def test_login__success(self, username, password, status, message, code):
  47.         login_data = {
  48.             "username": username,
  49.             "password": password,
  50.             "code": "2",
  51.             "uuid": TestLogin.uuid
  52.         }
  53.         response = self.login_api.login(test_data=login_data)
  54.         # 断言验证码
  55.         assert status == response.status_code
  56.         # 断言响应数据包含成功
  57.         assert message in response.text
  58.         # 断言响应json数据中的code值
  59.         assert code == response.json().get("code")
  60.         # 登录成功
  61.  
  62.     # 登录失败
  63.     @pytest.mark.parametrize("username, password, status, message, code", build_data(json_file=config1.BASE_PATH + "/data/login.json"))
  64.     def test_login_fail(self, username, password, status, message, code):
  65.         login_data = {
  66.             "username": username,
  67.             "password": password,
  68.             "code": "2",
  69.             "uuid": TestLogin.uuid
  70.         }
  71.         response = self.login_api.login(test_data=login_data)
  72.         # 断言验证码
  73.         assert status == response.status_code
  74.         # 断言响应数据包含成功
  75.         assert message in response.text
  76.         # 断言响应json数据中的code值
  77.         assert code == response.json().get("code")
  78.  
  79.  
  80.
2.11、allure生成测试报告

使用pip指令安装allure：pip install allure-pytest

然后下载并配置allure，下载地址：Central Repository: io/qameta/allure/allure-commandline

下载安装解压到指定目录，并将allure的bin目录路径配置到环境变量中系统变量的path。

配置完成后使用allure --version命令检测。

在pytest.ins文件中配置执行信息。包含报告输出信息、测试脚本路径、测试类、测试函数等

  1. [pytest]
  2. addopts =-s --alluredir report
  3. testpaths =./script
  4. python_files = test*.py
  5. python_classes = Test*
  6. python_functions = test*

在pychram的终端中使用命令：pytest 批量执行测试用例

使用allure serve report 命令查看测试报告：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/620371
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号