接口测试（六）—— 接⼝对象封装的思想和实现

心上学事上练

已于 2022-12-14 16:45:03 修改

阅读量279

点赞数

分类专栏： # 【接口测试】文章标签： python 开发语言接口测试

于 2022-12-14 16:40:21 首次发布

本文链接：https://blog.csdn.net/u010217055/article/details/128308787

版权

【接口测试】专栏收录该内容

12 篇文章 6 订阅

订阅专栏

一、接⼝对象封装

1、解决的问题

代码冗余度⾼（有⼤量重复代码）
代码耦合度⾼
代码维护成本⾼

2、核⼼思想：代码分层

分层思想：
将普通⽅法实现的，分为接⼝对象层和测试脚本层。
接⼝对象层：
对接⼝进⾏封装。封装好之后，给测试⽤例层调⽤！
⾯向对象类封装实现。
测试⽤例层：
调⽤接⼝对象层封装的⽅法，拿到响应结果，断⾔进⾏接⼝测试！
借助 unittest 框架实现

二、封装Tpshop商城

1、普通⽅式实现

import unittest
import requests

class TestTpshopLogin(unittest.TestCase):
    # 测试 登录成功
    def test01_login_ok(self):
        # 创建 session 实例
        session = requests.Session()

        # 使⽤实例，调⽤get 发送获取验证码请求
        session.get(url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=verify&r=0.21519623710645064")

        # 使⽤实例，调⽤post 发送登录请求
        resp = session.post(
            url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=do_login&t=0.7094195931397276",
            data={"username": "13012345678", "password": "123456", "verify_code":
"8888"})

        print("响应结果 =", resp.json())

        # 断⾔：
        self.assertEqual(200, resp.status_code)
        self.assertEqual(1, resp.json().get("status"))
        self.assertEqual("登陆成功", resp.json().get("msg"))

    # 测试 ⼿机号不存在
    def test02_tel_not_exists(self):
        # 创建 session 实例
        session = requests.Session()

        # 使⽤实例，调⽤get 发送获取验证码请求
        session.get(url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=verify&r=0.21519623710645064")

        # 使⽤实例，调⽤post 发送登录请求
        resp = session.post(
            url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=do_login&t=0.7094195931397276",
            data={"username": "13847834701", "password": "123456", "verify_code":
"8888"})
        print("响应结果 =", resp.json())

        # 断⾔：
        self.assertEqual(200, resp.status_code)
        self.assertEqual(-1, resp.json().get("status"))
        self.assertEqual("账号不存在!", resp.json().get("msg"))

    # 测试 密码错误
    def test03_pwd_err(self):
        # 创建 session 实例
        session = requests.Session()

        # 使⽤实例，调⽤get 发送获取验证码请求
        session.get(url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=verify&r=0.21519623710645064")

        # 使⽤实例，调⽤post 发送登录请求
        resp = session.post(
                url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=do_login&t=0.7094195931397276",
                data={"username": "13012345678", "password": "123456890",
"verify_code": "8888"})

        print("响应结果 =", resp.json())

        # 断⾔：
        self.assertEqual(200, resp.status_code)
        self.assertEqual(-2, resp.json().get("status"))
        self.assertEqual("密码错误!", resp.json().get("msg"))

2、登录接⼝对象层

封装思想：

将动态变化的数据，设计到⽅法的参数。
将固定不变的，直接写成⽅法实现。
将响应结果，通过返回值传出。

分析：

封装实现：

class TpshopLoginApi(object):
    # 发送验证码请求
    @classmethod
    def get_verify(cls, session):
        session.get(url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=verify&r=0.21519623710645064")

    # 发送登录请求
    @classmethod
    def login(cls, session, login_data):
        resp = session.post(
                url="http://tpshop-test.itheima.net/index.phpm=Home&c=User&a=do_login&t=0.7094195931397276",
                data=login_data)
        return resp

3、登录接⼝测试⽤例层

3.1 优化前：

import unittest
import requests
from tpshop_login_api import TpshopLoginApi

class TestTpshopLogin(unittest.TestCase):

    # 测试 登录成功
    def test01_login_ok(self):
        # 创建 session实例
        s = requests.Session()
        # ⽤实例，调⽤⾃⼰封装的 获取验证码 接⼝
        TpshopLoginApi.get_verify(s)
        # 调⽤ ⾃⼰封装的接⼝，登录
        abc = {"username": "13012345678", "password": "123456", "verify_code":
"8888"}
        resp = TpshopLoginApi.login(s, abc)
        print(resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(1, resp.json().get("status"))
        self.assertEqual("登陆成功", resp.json().get("msg"))

    # 测试 ⼿机号不存在
    def test02_tel_not_exists(self):
        # 创建 session实例
        s = requests.Session()
        # ⽤实例，调⽤⾃⼰封装的 获取验证码 接⼝
        TpshopLoginApi.get_verify(s)
        # 调⽤ ⾃⼰封装的接⼝，登录
        abc = {"username": "13048932745", "password": "123456", "verify_code":
"8888"}
        resp = TpshopLoginApi.login(s, abc)
        print(resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(-1, resp.json().get("status"))
        self.assertIn("账号不存在", resp.json().get("msg"))

        # 测试 密码错误
        def test03_pwd_err(self):
            # 创建 session实例
            s = requests.Session()
            # ⽤实例，调⽤⾃⼰封装的 获取验证码 接⼝
            TpshopLoginApi.get_verify(s)
            # 调⽤ ⾃⼰封装的接⼝，登录
            abc = {"username": "13012345678", "password": "123456789", "verify_code":
"8888"}
            resp = TpshopLoginApi.login(s, abc)
            print(resp.json())

            # 断⾔
            self.assertEqual(200, resp.status_code)
            self.assertEqual(-2, resp.json().get("status"))
            self.assertIn("密码错误", resp.json().get("msg"))

3.2 优化后

import unittest
import requests
from tpshop_login_api import TpshopLoginApi

# 封装 通⽤ 的 断⾔函数
def common_assert(self, resp, status_code, status, msg):
    self.assertEqual(status_code, resp.status_code)
    self.assertEqual(status, resp.json().get("status"))
    self.assertIn(msg, resp.json().get("msg"))

class TestTpshopLogin(unittest.TestCase):
    # 添加类属性
    session = None

    @classmethod
    def setUpClass(cls) -> None: # 在 类中 所 有 测试⽅法执⾏之前，⾃动执⾏1次。
        cls.session = requests.Session()

    def setUp(self) -> None: # 在 每个 测试⽅法执⾏之前，⾃动执⾏1次。
        # 调⽤ ⾃⼰封装的接⼝，获取验证码
        TpshopLoginApi.get_verify(self.session)

    # 测试 登录成功
    def test01_login_ok(self):
        # 调⽤ ⾃⼰封装的接⼝，登录
        data = {"username": "13012345678", "password": "123456", "verify_code":"8888"}
        resp = TpshopLoginApi.login(self.session, data)
        # 断⾔
        common_assert(self, resp, 200, 1, "登陆成功")

    # 测试 ⼿机号不存在
    def test02_tel_not_exists(self):
        # 调⽤ ⾃⼰封装的接⼝，登录
        data = {"username": "13048392845", "password": "123456", "verify_code":"8888"}
        resp = TpshopLoginApi.login(self.session, data)
        # 断⾔
        common_assert(self, resp, 200, -1, "账号不存在")

    # 测试 密码错误
    def test03_pwd_err(self):
        # 调⽤ ⾃⼰封装的接⼝，登录
        data = {"username": "13012345678", "password": "123456890", "verify_code":"8888"}
        resp = TpshopLoginApi.login(self.session, data)
        # 断⾔
        common_assert(self, resp, 200, -2, "密码错误")

三、封装iHRM登录

登录接⼝

1、普通⽅式实现

import unittest
import requests

class TestIhrmLogin(unittest.TestCase):
    # 登陆成功
    def test01_login_success(self):
        resp = requests.post(url="http://ihrm-test.itheima.net/api/sys/login",
                    json={"mobile": "13800000002", "password": "123456"})
        print(resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(True, resp.json().get("success"))
        self.assertEqual(10000, resp.json().get("code"))
        self.assertIn("操作成功", resp.json().get("message")

2、登录接⼝对象层

思路：
动态变化的，写⼊参数
固定不变，直接写到⽅法实现内
响应结果，通过返回值 return
分析：
封装实现：
# 接⼝对象层
import requests

class IhrmLoginApi(object):
    @classmethod
    def login(cls, json_data):
        resp = requests.post(url="http://ihrm-test.itheima.net/api/sys/login",
                    json=json_data)
        return resp

3、登录接⼝测试⽤例层

import unittest
from ihrm_login_api import IhrmLoginApi

# 定义测试类
class TestIhrmLogin(unittest.TestCase):
    # 测试⽅法 - 登录成功
    def test01_login_success(self):
        # 调⽤ ⾃⼰封装 login
        login_data = {"mobile": "13800000002", "password": "123456"}
        resp = IhrmLoginApi.login(login_data)
        print("登录成功:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(True, resp.json().get("success"))
        self.assertEqual(10000, resp.json().get("code"))
        self.assertIn("操作成功", resp.json().get("message"))

    # 测试⽅法 - ⼿机号未注册
    def test02_mobile_not_register(self):
        # 调⽤ ⾃⼰封装 login
        login_data = {"mobile": "1384780932", "password": "123456"}
        resp = IhrmLoginApi.login(login_data)
        print("⼿机号未注册:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(False, resp.json().get("success"))
        self.assertEqual(20001, resp.json().get("code"))
        self.assertIn("⽤户名或密码错误", resp.json().get("message"))

    # 测试⽅法 - 密码错误
    def test03_pwd_error(self):
        # 调⽤ ⾃⼰封装 login
        login_data = {"mobile": "13800000002", "password": "890"}
        resp = IhrmLoginApi.login(login_data)
        print("密码错误:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(False, resp.json().get("success"))
        self.assertEqual(20001, resp.json().get("code"))
        self.assertIn("⽤户名或密码错误", resp.json().get("message"))

    # 测试⽅法 - ⼿机号为空
    def test04_mobile_is_none(self):
        # 调⽤ ⾃⼰封装 login
        login_data = {"mobile": None, "password": "123456"}
        resp = IhrmLoginApi.login(login_data)
        print("⼿机号为空:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(False, resp.json().get("success"))
        self.assertEqual(20001, resp.json().get("code"))
        self.assertIn("⽤户名或密码错误", resp.json().get("message"))

    # 测试⽅法 - 多参
    def test12_more_params(self):
        # 调⽤ ⾃⼰封装 login
        login_data = {"mobile": "13800000002", "password": "123456", "abc":"123"}
        resp = IhrmLoginApi.login(login_data)
        print("⼿机号为空:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(True, resp.json().get("success"))
        self.assertEqual(10000, resp.json().get("code"))
        self.assertIn("操作成功", resp.json().get("message"))

    # 测试⽅法 - ⽆参
    def test14_none_params(self):
        # 调⽤ ⾃⼰封装 login
        login_data = None
        resp = IhrmLoginApi.login(login_data)
        print("⼿机号为空:", resp.json())

        # 断⾔
        self.assertEqual(200, resp.status_code)
        self.assertEqual(False, resp.json().get("success"))
        self.assertEqual(99999, resp.json().get("code"))
        self.assertIn("抱歉，系统繁忙，请稍后重试", resp.json().get("message"))

4、封装断⾔⽅法

1. 创建⽂件 assert_util.py
2. 在⽂件内，定义 common_assert() 函数
3. 直接粘贴 unittest框架中的断⾔代码，修改参数。
4. 回到 unittest框架实现的测试脚本中，调⽤该函数，实现断⾔，传递实际参数。

# 定义 断⾔ 函数
# def common_assert():
# self.assertEqual(200, resp.status_code) # self / resp 报错
# self.assertEqual(True, resp.json().get("success"))
# self.assertEqual(10000, resp.json().get("code"))
# self.assertIn("操作成功", resp.json().get("message"))

def common_assert(self, resp, status_code, success, code, message):
    self.assertEqual(status_code, resp.status_code)
    self.assertEqual(success, resp.json().get("success"))
    self.assertEqual(code, resp.json().get("code"))
    self.assertIn(message, resp.json().get("message"))

# 调⽤演示
    common_assert(self, resp, 200, True, 10000, "操作成功")
    common_assert(self, resp, 200, False, 20001, "⽤户名或密码错误")
    common_assert(self, resp, 200, False, 99999, "抱歉，系统繁忙，请稍后重试")

三、Tpshop商城参数化

1、准备⼯作

分析 tpshop 商城测试⽤例：

提取每个测试⽤例使⽤的 测试数据 和 断⾔数据。

封装函数，将数据 转换为元组列表。

2、参数化步骤

1. 导包 from parameterized import parameterized
2. 在通⽤测试⽅法，上⼀⾏，添加 @parameterized.expand()
3. 给 expand() 传⼊ [(),(),()]（调⽤转换 [{},{},{}] --> [(),(),()] 的函数）
4. 修改通⽤测试⽅法，添加形参，个数、顺序，与 [{},{},{}] 中 { } 内的所有 key 完全⼀⼀对应。
5. 在通⽤测试⽅法内，使⽤形参。
from parameterized import parameterized

class TestTpshopLogin(unittest.TestCase):
    # 添加类属性
    session = None

    @classmethod
    def setUpClass(cls) -> None:
        cls.session = requests.Session()

    def setUp(self) -> None:
        # 调⽤ ⾃⼰封装的接⼝，获取验证码
        TpshopLoginApi.get_verify(self.session)

    # 测试 tpshop 登录
    @parameterized.expand(read_json_data())
    def test_tpshop_login(self, req_body, status_code, status, msg):
        resp = TpshopLoginApi.login(self.session, req_body)
        common_assert(self, resp, status_code, status, msg)

Python 参数化参考：软件测试 —— Python(七)之UnitTest框架与测试报告

心上学事上练

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
接口测试（六）—— 接⼝对象封装的思想和实现

4. 修改通⽤测试⽅法，添加形参，个数、顺序，与 [{},{},{}] 中 { } 内的所有 key 完全⼀⼀对应。传⼊ [(),(),()]（调⽤转换 [{},{},{}] --> [(),(),()] 的函数）4. 回到 unittest框架实现的测试脚本中，调⽤该函数，实现断⾔，传递实际参数。2. 在⽂件内，定义 common_assert() 函数。2. 在通⽤测试⽅法，上⼀⾏，添加。5. 在通⽤测试⽅法内，使⽤形参。3、登录接⼝测试⽤例层。3、登录接⼝测试⽤例层。
复制链接

扫一扫