基本概念

接口上下游传参 一般就是值 多个接口串联

接口上下游传参 - 图1
上面三个接口 就有很强的关联性

  1. 注册用户
  2. 用户登录
  3. 搜索商品

登录成功之后，会返回 token 值
token 每次登录成功 — 每次都不一样。
在搜索商品的时候 需要使用到 token值。

处理注册接口与登录接口

将注册使用的手机号和 登录使用的手机号 统一放在最外层。

  2. import random
  3. import requests
  4. import hashlib
  6. def get_phone():
  7.     """
  8.     生成随机的11位手机号码
  9.     手机号的前缀； ['13','17','18','15']
  10.     后面需要随机生成 9位数。
  11.     :return:
  12.     """
  13.     # 手机号码前缀  从列表中随机选择其中的一个值
  14.     pre_phone = random.choice(['13','17','18','15'])
  15.     # 随机的一个值
  16.     nums = ""
  17.     for i in range(9):
  18.         # 每次随机的时候 生成 0-9 之间的一个数字
  19.         num = random.randint(0,9)
  20.         # 每次生成一个新的随机值 做一次拼接
  21.         nums = nums + str(num)
  22.     # 前缀和后面的值拼接在一起 组成手机号
  23.     return pre_phone+nums
  25. # 将公共使用的手机号码放在最外层
  26. phone = get_phone()
  28. def test_register():
  29.     """
  30.     注册用户
  31.     :return:
  32.     """
  33.     url = "http://49.233.108.117:28019/api/v1/user/register"
  34.     body_data = {
  35.         "loginName": phone,  # 通过调用函数 生成手机号码
  36.         "password": "123456"
  37.     }
  38.     print(f'现在进行注册：用户名{phone},密码为123456')
  39.     # 发送 json 格式 post请求
  40.     r = requests.post(url, json=body_data)
  41.     # 状态码
  42.     print(r.status_code)
  43.     print(r.json())
  45. def test_login():
  46.     """
  47.     用户登录
  48.     :return:
  49.     """
  50.     passwd = hashlib.md5('123456'.encode()).hexdigest()
  52.     url = "http://49.233.108.117:28019/api/v1/user/login"
  53.     body_data = {
  54.         "loginName": phone,
  55.         "passwordMd5": passwd  # 使用md5 加密之后的密文进行登录
  56.     }
  57.     print(f'现在进行登录: 用户名为 {phone},加密之后的密码 {passwd}')
  58.     r = requests.post(url, json=body_data)
  59.     print(r.status_code)
  60.     print(r.json())
  63. def test_search():
  64.     """
  65.     搜索商品
  66.     :return:
  67.     """
  70. if __name__ == '__main__':
  71.     test_register()
  72.     test_login()

上下游参数关联

上面的注册和登录例子 使用的都是 同一个手机号码。 只需要将手机号码设置到函数外面即可。
如果 上一个接口的出参 作为 下一个接口的入参，这种类型的接口处理起来就需要别的操作的。

代码示例

  1. n = 0
  3. def f1():
  4.     n = 1
  5.     print(n)
  7. def f2():
  8.     print(n)
  10. if __name__ == '__main__':
  11.     f1()  # 1
  12.     f2()  # 0

如果我想将f1 中的值 传递给 f2
可以借助 字典数据类型进行参数的传递

  1. import random
  2. testdata = {
  3.     "f1":0
  4. }
  6. def f1():
  7.     n = random.randint(100,999)
  8.     print(n)
  9.     # 将n的随机值 赋给 字典中的 f1
  10.     testdata['f1'] = n
  12. def f2():
  13.     """
  14.     我希望在这个函数中引用 f1 函数中生成 随机值
  15.     :return:
  16.     """
  17.     # 取到的值 与 f1 中的值是一样的
  18.     print(testdata['f1'])
  21. if __name__ == '__main__':
  22.     f1()
  23.     f2()

搜索商品

根据接口文档，搜索商品 在 信息头中添加token 值，token是从登录接口中，每次登录，返回的token值都不一样。

搜索商品接口
请求方式 ：GET
请求路径：http://49.233.108.117:28019/api/v1/search
请求参数:

  1. {
  2. "keyword":"商品名"
  3. }

请求headers

  1. {
  2.     "token":"登录接口返回的token值"
  3. }

Python代码

在函数外部定义字典数据类型，在字典中定义 token字段
登录成功之后 更新字典中的token的值。
后面的接口中使用 需要使用到token 直接引用 字典中token。

  2. import random
  3. import requests
  4. import hashlib
  5. # 设置初始的测试数据，token值默认为None
  6. testdata = {
  7.     "token":None
  8. }
  10. def get_phone():
  11.     """
  12.     生成随机的11位手机号码
  13.     手机号的前缀； ['13','17','18','15']
  14.     后面需要随机生成 9位数。
  15.     :return:
  16.     """
  17.     # 手机号码前缀  从列表中随机选择其中的一个值
  18.     pre_phone = random.choice(['13','17','18','15'])
  19.     # 随机的一个值
  20.     nums = ""
  21.     for i in range(9):
  22.         # 每次随机的时候 生成 0-9 之间的一个数字
  23.         num = random.randint(0,9)
  24.         # 每次生成一个新的随机值 做一次拼接
  25.         nums = nums + str(num)
  26.     # 前缀和后面的值拼接在一起 组成手机号
  27.     return pre_phone+nums
  29. # 将公共使用的手机号码放在最外层
  30. phone = get_phone()
  32. def test_register():
  33.     """
  34.     注册用户
  35.     :return:
  36.     """
  37.     url = "http://49.233.108.117:28019/api/v1/user/register"
  38.     body_data = {
  39.         "loginName": phone,  # 通过调用函数 生成手机号码
  40.         "password": "123456"
  41.     }
  42.     print(f'现在进行注册：用户名{phone},密码为123456')
  43.     # 发送 json 格式 post请求
  44.     r = requests.post(url, json=body_data)
  45.     # 状态码
  46.     print(r.status_code)
  47.     print(r.json())
  49. def test_login():
  50.     """
  51.     用户登录
  52.     :return:
  53.     """
  54.     passwd = hashlib.md5('123456'.encode()).hexdigest()
  56.     url = "http://49.233.108.117:28019/api/v1/user/login"
  57.     body_data = {
  58.         "loginName": phone,
  59.         "passwordMd5": passwd  # 使用md5 加密之后的密文进行登录
  60.     }
  61.     print(f'现在进行登录: 用户名为 {phone},加密之后的密码 {passwd}')
  62.     r = requests.post(url, json=body_data)
  63.     print(r.status_code)
  64.     print(r.json())
  65.     print("登录成功的token值:",r.json()["data"])
  66.     # 将获取到的token值更新在 字典中
  67.     testdata['token'] = r.json()['data']
  70. def test_search():
  71.     """
  72.     搜索商品
  73.     :return:
  74.     """
  75.     url = "http://49.233.108.117:28019/api/v1/search"
  76.     qury_data = {
  77.         "keyword":"iphone"
  78.         }
  79.     header = {
  80.         "token": testdata['token']   # 引用登录成功之后更新的token值
  81.     }
  82.     print(f'现在搜索商品,使用信息头: {header}')
  84.     r = requests.get(url,params=qury_data,headers=header)
  85.     print('搜索结果',r.json())
  86. if __name__ == '__main__':
  87.     test_register()
  88.     test_login()
  89.     test_search()

也是使用 字典数据类型的方式，将值放在字典，
登录成功之后 更新字典的值
搜索接口中 引用已经更新好的值。

也可以使用类变量的方式进行参数传递

python 类代码

  1. import random
  2. import requests
  3. import hashlib
  5. def get_phone():
  6.     """
  7.     生成随机的11位手机号码
  8.     手机号的前缀； ['13','17','18','15']
  9.     后面需要随机生成 9位数。
  10.     :return:
  11.     """
  12.     # 手机号码前缀  从列表中随机选择其中的一个值
  13.     pre_phone = random.choice(['13','17','18','15'])
  14.     # 随机的一个值
  15.     nums = ""
  16.     for i in range(9):
  17.         # 每次随机的时候 生成 0-9 之间的一个数字
  18.         num = random.randint(0,9)
  19.         # 每次生成一个新的随机值 做一次拼接
  20.         nums = nums + str(num)
  21.     # 前缀和后面的值拼接在一起 组成手机号
  22.     return pre_phone+nums
  25. class TestConfigData:
  26.     # 类变量的方式获取 手机号
  27.     PHONE = get_phone()
  28.     # 设置初始的token
  29.     TOKEN = None
  32. class TestShopApi:
  34.     def test_register(self):
  35.         """
  36.         注册用户
  37.         :return:
  38.         """
  39.         url = "http://49.233.108.117:28019/api/v1/user/register"
  40.         body_data = {
  41.             "loginName": TestConfigData.PHONE,  # 通过调用函数 生成手机号码
  42.             "password": "123456"
  43.         }
  44.         print(f'现在进行注册：用户名{TestConfigData.PHONE},密码为123456')
  45.         # 发送 json 格式 post请求
  46.         r = requests.post(url, json=body_data)
  47.         # 状态码
  48.         print(r.status_code)
  49.         print(r.json())
  51.     def test_login(self):
  52.         """
  53.         用户登录
  54.         :return:
  55.         """
  56.         passwd = hashlib.md5('123456'.encode()).hexdigest()
  58.         url = "http://49.233.108.117:28019/api/v1/user/login"
  59.         body_data = {
  60.             "loginName": TestConfigData.PHONE,
  61.             "passwordMd5": passwd  # 使用md5 加密之后的密文进行登录
  62.         }
  63.         print(f'现在进行登录: 用户名为 { TestConfigData.PHONE},加密之后的密码 {passwd}')
  64.         r = requests.post(url, json=body_data)
  65.         print(r.status_code)
  66.         print(r.json())
  67.         print("登录成功的token值:", r.json()["data"])
  68.         # 将登录成功的token 值更新到类变量中
  69.         TestConfigData.TOKEN = r.json()['data']
  71.     def test_search(self):
  72.         """
  73.         搜索商品
  74.         :return:
  75.         """
  76.         url = "http://49.233.108.117:28019/api/v1/search"
  77.         qury_data = {
  78.             "keyword": "iphone"
  79.         }
  80.         header = {
  81.             # 使用类变量 获取最新的token值
  82.             "token": TestConfigData.TOKEN
  83.         }
  84.         print(f'现在搜索商品,使用信息头: {header}')
  86.         r = requests.get(url, params=qury_data, headers=header)
  87.         print('搜索结果', r.json())
  90. if __name__ == '__main__':
  91.     t1 = TestShopApi()
  92.     t1.test_register()
  93.     t1.test_login()
  94.     t1.test_search()

思维导图

接口上下游传参 - 图2