1. 首页
  2. 文章资讯

【接口自动化测试】第四节.实现项目核心业务的单接口自动化测试

3 阅读 0 评论

文章目录

  • 前言
  • 一、登录单接口自动化测试
  •       1.1 登录单接口文档信息
  •       1.2 登录成功
  •       1.3 登录失败（用户名为空）
  • 二、数据驱动的实现
  •       2.1 json文件实现数据驱动
  • 三、课程添加单接口自动化测试
  •       3.1 课程添加单接口文档信息
  •       3.2 课程添加成功
  •       3.3 课程添加失败（未登录）
  • 四、课程查询单接口自动化测试
  •       4.1 课程查询单接口文档信息
  •       4.2 课程查询成功
  •       4.3 课程查询失败（用户未登录）
  • 五、课程修改单接口自动化测试
  •       5.1 课程修改单接口文档信息
  •       5.2 课程修改成功
  •       5.3 课程修改失败（用户未登录）
  • 六、课程删除单接口自动化测试
  •       6.1 课程删除单接口文档信息
  •       6.2 课程删除成功
  •       6.3 课程删除失败（用户名为空）
  • 七、项目配置文件
  • 八、Allure报告
  • 总结

前言

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

1.1 登录单接口文档信息

需求：
  • 完成测试脚本的业务实现
  • 针对响应结果进行断言

1.2 登录成功

登录成功接口文档信息：

登录成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理

# 导包
from api.login import LoginAPI


# 创建测试类
class TestLoginAPI:
    # 初始化
    uuid = None

    # 前置处理
    def setup(self):
        # 实例化接口类
        self.login_api = LoginAPI()
        # 获取验证码
        response = self.login_api.get_verify_code()
        print(response.json())
        # 提取验证码接口返回的uuid参数值
        TestLoginAPI.uuid = response.json().get("uuid")
        print(TestLoginAPI.uuid)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建登录成功方法，并实现获取验证码和登录操作

# 登录成功
    def test01_success(self):
        login_data = {
            "username": "manager",
            "password": "123456",
            "code": "2",
            "uuid": TestLoginAPI.uuid
        }
        response = self.login_api.login(test_data=login_data)

步骤3：针对响应结果进行断言

  # 断言响应状态码为200
        assert 200 == response.status_code
        # 断言响应数据包含'成功'
        assert '成功' in response.text
        # 断言响应json数据中code值
        assert 200 == response.json().get("code")

断言依据：

1.3 登录失败（用户名为空）

登录失败（用户名为空）文档信息：

登录成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI


# 创建测试类
class TestLoginAPI:
    # 初始化
    uuid = None

    # 前置处理
    def setup(self):
        # 实例化接口类
        self.login_api = LoginAPI()
        # 获取验证码
        response = self.login_api.get_verify_code()
        print(response.json())
        # 提取验证码接口返回的uuid参数值
        TestLoginAPI.uuid = response.json().get("uuid")
        print(TestLoginAPI.uuid)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建登录失败（用户名为空）方法

# 登录失败（用户名为空）
    def test02_without_username(self):
        login_data = {
            "username": "",//此处用户名设置为空
            "password": "123456",
            "code": "2",
            "uuid": TestLoginAPI.uuid
        }
        response = self.login_api.login(test_data=login_data)

步骤3：针对响应结果进行断言

# 断言响应状态码为200
        assert 200 == response.status_code
        # 断言响应数据包含'错误'
        assert '错误' in response.text
        # 断言响应json数据中code值
        assert 500 == response.json().get("code")

断言依据：

二、数据驱动的实现

1.什么是数据驱动？
维护焦点：测试数据
数据驱动：
以测试数据驱动脚本执行，维护焦点从脚本转向测试数据的一种自动化 测试设计模式。
图示说明：
维护测试数据：

2.如何实现数据驱动？

图示说明：

pytest中parametrize装饰器
（1）作用：遍历所有测试数据并运行测试方法。
（2） 语法：
@pytest.mark.parametrize ( ②保存数据参数名, ①测试数据 )
def test_method(self, ③参数名 )
pass
示例：
test_data = [( "manager", "123456" ), ("", "123456"), ("itheima", "123456")]
@pytest.mark.parametrize(" mobile, passwd ", test_data )
def test_login(self, mobile, passwd )
pass
对应上面语法。

针对登录接口实现步骤:

需求：
针对登录接口，将请求数据和断言数据组织成JSON文件，完成自动化测试。
步骤1：准备测试数据 
# 测试数据①测试数据
 test_data = [
     ("manager", "123456", 200, '成功', 200),
     ("", "123456", 200, '错误', 500),
     ("jack666", "123456", 200, '错误', 500),
 ]

步骤2：所以pytest中parametrize装饰器

#登录单接口实现
@pytest.mark.parametrize(②保存数据参数名"username, password, status, message, code" ，①测试数据test_data)
    def test01_success(self, ③参数名username, password, status, message, code):
        login_data = {
            "username": username,
            "password": password,
            "code": "2",
            "uuid": TestLoginAPI.uuid
        }
        response = self.login_api.login(test_data=login_data)
        # 断言响应状态码为200
        assert status == response.status_code
        # 断言响应数据包含'成功'
        assert message in response.text
        # 断言响应json数据中code值
        assert code == response.json().get("code")

2.1 json文件实现数据驱动

json文件实现数据驱动实现步骤：

步骤1：创建data目录下面的login.json文件用于存储json数据

[
    {
        "username": "manager",
        "password": "123456",
        "status": 200,
        "message": "成功",
        "code": 200
    },
    {
        "username": "",
        "password": "123456",
        "status": 200,
        "message": "错误",
        "code": 500
    },
    {
        "username": "jack666",
        "password": "123456",
        "status": 200,
        "message": "错误",
        "code": 500
    }
]

步骤2：导入json数据文件

# 导包
import json

# 读取json文件
def build_data(json_file):

步骤3：读取json数据文件

# 读取json文件
def build_data(json_file):
    # 1.定义空列表
    test_data = []
    # 2.打开json文件
    with open(json_file, "r") as f:
        # 3.加载json文件数据
        json_data = json.load(f)
        # 4.循环遍历测试数据
        for case_data in json_data:
            # 转换数据格式[{},{}] ==> [(),()]
            username = case_data.get("username")
            password = case_data.get("password")
            status = case_data.get("status")
            message = case_data.get("message")
            code = case_data.get("code")
            test_data.append((username, password, status, message, code))
    # 返回处理之后测试数据
    return test_data

 # 登录成功
    # @pytest.mark.parametrize("username, password, status, message, code", build_data(json_file="../data/login.json"))

三、课程添加单接口自动化测试

3.1 课程添加单接口文档信息

需求：
完成测试脚本的业务实现
针对响应结果进行断言

3.2 课程添加成功

课程添加成功成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程添加成功方法

 # 课程添加成功
    def test01_add_success(self):
        add_data = {
            "name": "测试开发提升课01",
            "subject": "6",
            "price": 899,
            "applicablePerson": "2"
        }
        response = self.course_api.add_course(test_data=add_data, token=TestCourseAPI.TOKEN)
        print(response.json())

步骤3：针对响应结果进行断言

 # 断言响应状态码
        assert 200 == response.status_code
        # 断言返回数据中包含指定的文字
        assert "成功" in response.text
        # 断言json返回数据code值
        assert 200 == response.json().get("code")

断言依据：

3.3 课程添加失败（未登录）

 课程添加失败（未登录）测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程添加失败（未登录）

# 课程添加失败（未登录）
    def test02_add_fail(self):
        add_data = {
            "name": "测试开发提升课02",
            "subject": "6",
            "price": 899,
            "applicablePerson": "2"
        }
        response = self.course_api.add_course(test_data=add_data, token="xxx")
        print(response.json())

步骤3：针对响应结果进行断言

# 断言响应状态码
        assert 200 == response.status_code
        # 断言返回数据中包含指定的文字
        assert "认证失败" in response.text
        # 断言json返回数据code值
        assert 401 == response.json().get("code")

断言依据：

四、课程查询单接口自动化测试

4.1 课程查询单接口文档信息

需求：
完成测试脚本的业务实现
针对响应结果进行断言

4.2 课程查询成功

 

 课程查询成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程查询成功

# 查询存在的课程
    def test01_select_success(self):
        response = self.course_api.select_course(test_data="?name=测试开发提升课01", token=TestCourseAPI.TOKEN)
        print(response.json())

步骤3：针对响应结果进行断言

     # 断言响应状态码
        assert 200 == response.status_code
        # 断言msg中包含指定的文字
        assert "成功" in response.text
        # 断言json返回数据中code值
        assert 200 == response.json().get("code")

断言依据：

4.3 课程查询失败（用户未登录）

 课程查询失败（用户未登录）测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程查询成功

# 查询失败（用户未登录）
    def test02_select_fail(self):
        response = self.course_api.select_course(test_data="?subject=6", token="xxx")
        print(response.json())

步骤3：针对响应结果进行断言

   # 断言响应状态码
        assert 200 == response.status_code
        # 断言msg中包含指定的文字
        assert "认证失败" in response.text
        # 断言json返回数据中code值
        assert 401 == response.json().get("code")

断言依据：

五、课程修改单接口自动化测试

5.1 课程修改单接口文档信息

需求：
完成测试脚本的业务实现
针对响应结果进行断言

5.2 课程修改成功

课程修改成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程修改成功

 # 课程修改成功
    def test01_update_success(self):
        update_data = {
            "id": 109,
            "name": "接口测试001",
            "subject": "6",
            "price": 998,
            "applicablePerson": "2",
            "info": "课程介绍001"
        }
        response = self.course_api.update_course(test_data=update_data, token=TestCourseAPI.TOKEN)
        print(response.json())

步骤3：针对响应结果进行断言

# 断言响应状态码
        assert 200 == response.status_code
        # 断言返回消息
        assert "成功" in response.text
        # 断言code值
        assert 200 == response.json().get("code")

断言依据：

5.3 课程修改失败（用户未登录）

 课程修改失败（用户未登录）测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：创建课程修改成功

# 课程修改失败（未登录）
    def test02_update_fail(self):
        update_data = {
            "id": 109,
            "name": "接口测试001",
            "subject": "6",
            "price": 998,
            "applicablePerson": "2",
            "info": "课程介绍001"
        }
        response = self.course_api.update_course(test_data=update_data, token="xxx")
        print(response.json())

步骤3：针对响应结果进行断言

# 断言响应状态码
        assert 200 == response.status_code
        # 断言返回消息
        assert "认证失败" in response.text
        # 断言code值
        assert 401 == response.json().get("code")

断言依据：

六、课程删除单接口自动化测试

6.1 课程删除单接口文档信息

需求：
完成测试脚本的业务实现
针对响应结果进行断言

6.2 课程删除成功

课程删除成功测试脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：课程删除成功

  # 课程删除成功
    def test01_delete_success(self):
        response = self.course_api.delete_course(course_id=110, token=TestCourseAPI.TOKEN)
        print(response.json())

步骤3：针对响应结果进行断言

 # 断言响应状态码
        assert 200 == response.status_code
        # 断言返回消息
        assert "成功" in response.text
        # 断言code值
        assert 200 == response.json().get("code")

断言依据：

6.3 课程删除失败（用户名为空）

课程删除失败（用户名为空）脚本层编写：

实现步骤：

步骤1：导包、创建测试类、前置，后置处理（和登录成功一样的）

# 导包
from api.login import LoginAPI
from api.course import CourseAPI


# 创建测试类
class TestCourseAPI:
    # 初始化
    TOKEN = None

    # 前置处理
    def setup(self):
        # 初始化接口类
        self.login_api = LoginAPI()
        self.course_api = CourseAPI()
        # 登录成功
        # 获取验证码
        res_v = self.login_api.get_verify_code()
        # 登录
        login_data = {
            "username": "admin",
            "password": "admin123",
            "code": "2",
            "uuid": res_v.json().get("uuid")
        }
        res_l = self.login_api.login(test_data=login_data)
        # 提取登录成功的token数据并保存
        TestCourseAPI.TOKEN = res_l.json().get("token")
        print(TestCourseAPI.TOKEN)

    # 后置处理
    def teardown(self):
        pass

前置处理是处理获取验证码的uuid信息，用于登录接口使用。

步骤2：课程删除失败（用户名为空）

# 课程删除失败（用户未登录）
    def test03_delete_fail(self):
        response = self.course_api.delete_course(course_id=110, token="xxx")
        print(response.json())

步骤3：针对响应结果进行断言

  # 断言响应状态码
        assert 200 == response.status_code
        # 断言返回消息
        assert "认证失败" in response.text
        # 断言code值
        assert 401 == response.json().get("code")

断言依据：

七、项目配置文件

测试环境 （kdtx-test.itheima.net） 测试通过后，我们的代 码能直接在生产环境
（kdtx.itheima.net）上 运行吗？
apiTestFramework # 项目名称
├── api # 定义封装被测系统的接口
├── script # 定义测试用例脚本
├── data # 存放测试数据文件
├── report # 存放生成的测试报告
├── common # 存放通用工具类
├── config.py # 定义项目的配置信息
└── pytest.ini # pytest配置文件
配置文件config.py的步骤：
# 导包
import os
# 定义环境域名
BASE_URL = "http://kdtx-test.itheima.net"
# 统一文件路径
BASE_PATH = os.path.dirname(__file__)
print(BASE_PATH)

八、Allure报告

（1）Allure介绍

1.介绍
• 能生成美观易读的报告
• 支持多种开发语言，如java、python等
• 能快速上手
 2.操作步骤
① 生成测试结果文件（json文件）
② 使用allure命令生成在线报告

步骤1：生成测试结果文件

安装：pip install allure-pytest
使用步骤：
1. 将pytest配置文件中的命令行参数加上如下代码
--alluredir report
2. 编写好测试脚本后，在命令行行中运行pytest
[pytest]
addopts = -s --alluredir report
testpaths = ./scripts
python_files = test*.py
python_classes = Test*
python_functions = test*
3. 程序运行结束后，会在项目的report目录中生成一些json文件

步骤2：使用allure生成在线报告

安装：
1. https://github.com/allure-framework/allure2/releases 下载 allure
2. 解压缩安装包到一个 不包含中文路径 的目录
3. 将压缩包内的 bin 目录配置到 path 系统环境变量
4. 右键我的电脑 - 属性 - 高级设置 - 环境变量 - 找到系统环境变量的path项 - 增加 allure到bin目录
5. 在命令行中输入 allure --version 命令，能显示allure版本信息，即为成功

总结

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处： 免费源码网-免费的源码资源网站 » 【接口自动化测试】第四节.实现项目核心业务的单接口自动化测试

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

 发表
评论 返回
顶部