接口串联

在做一些有业务关联的接口时 需要接口之间进行数据传递。
上下游传参 - 图1
这两个接口在做测试的时候，需要接口串联， 每次生成的topic_id值都不一样，需要动态从上游接口中提取出来传递给下游接口。

在接口串联之间，先说明一下 函数中参数的作用域。

函数内部定义的变量

  1. # 定义变量a
  2. a = 10
  3. def f1():
  4.     a = 20  # 函数内部定义变量 a
  5.     print(f"f1-a {a}")
  7. if __name__ == '__main__':
  8.     f1()

代码执行结果为20
image.png
因为f1 函数内部 a=20 执行函数的时候，如果函数内部定义的有变量，函数在运行的过程中，会优先使用函数内部定义的变量。 所以执行结果为20。

  1. # 定义变量a
  2. a = 10
  3. def f1():
  4.     a = 20  # 函数内部定义变量 a  这个 a的值 只在 函数内有效。
  5.     print(f"f1-a {a}")
  7. print(f"文件中的a的值 {a}")  # 10
  9. if __name__ == '__main__':
  10.     f1()
  1. # 定义变量a
  2. a = 10
  3. def f1():
  4.     a = 20  # 函数内部定义变量 a  这个 a的值 只在 函数内有效。
  5.     print(f"f1-a {a}")
  7. def f2():
  8.     print(f"a的值为 {a}")
  10. # print(f"文件中的a的值 {a}")  # 10
  12. if __name__ == '__main__':
  13.     f1()
  14.     f2()  # 10  取文件中定义的a的值

字典值跨函数使用

  1. # 随机函数
  2. import random
  3. # 定义字典  可以通过修改 key 对应的value
  4. data = {
  5.     "rn": None
  6. }
  8. def f1():
  9.     # 随机生成一个数字
  10.     num = random.randint(1,100000)
  11.     # 修改字典中 rn字段的值
  12.     data["rn"] = num
  13.     print(f'f1 生成随机数字 {num}')
  15. def f2():
  16.     """
  17.     需要将 f1函数中生成 随机数字 传递过来，进行使用。
  18.     :return:
  19.     """
  20.     print(f'f2 使用f1生成的随机数字：{data["rn"]}')
  22. if __name__ == '__main__':
  23.     f1()
  24.     f2()

image.png

字典类型中数据 是可变类型。主要就是通过使用这种可变方式的特性，在上游接口中更改字典中对应字段的值，在下游接口中引用字典字段的值。 通过字典数据的方式来进行参数串联。

接口中的参数串联

利用字典的特性，实现CNnode 主要接口的参数串联。

  1. """
  2. cnode 社区接口作业
  3. """
  4. import requests
  6. # 定义请求地址前缀
  7. baseurl = "http://47.100.175.62:3000/api/v1"
  8. token = "e80fce05-b85c-445e-a26e-66172deffb24"
  9. # 预先定义字典格式的数据
  10. test_data={
  11.     "topic_id":"",   # 需要进行上下游传参的字段  初始值为 空字符串
  12.     "reply_id":""   # 评论id 需要进行上下游传参，  初始值设置为 空字符
  13. }
  15. def test_add_topic():
  16.     """
  17.     创建话题
  18.     :return:
  19.     """
  20.     url = baseurl+"/topics"
  21.     body_data = {
  22.         "accesstoken": token,
  23.         "title":"hehehehehehe",
  24.         "tab":"ask",
  25.         "content":"xxxxxxxxxxxx"
  26.     }
  27.     r = requests.post(url,json=body_data)
  28.     print("新建主题：",r.status_code,r.json())
  29.     # 从返回结果中提起 话题的id
  30.     tid = r.json()["topic_id"]
  31.     # 将提取出来的值tid 更新到 外边定义的字典中 test_data[”topic_id”]
  32.     test_data["topic_id"] = tid  # 上游更新值
  35. def test_edit_topic():
  36.     """
  37.     编辑话题
  38.     :return:
  39.     """
  40.     url = baseurl + "/topics/update"
  41.     body_data = {
  42.         "accesstoken": token,
  43.         # "topic_id":"625cc91ceb0fc111c4a0d584",
  44.         "topic_id": test_data["topic_id"] ,   # 通过字典 topic_id 字段引用最新的值。
  45.         "title": "hehehehehehe",
  46.         "tab": "ask",
  47.         "content": "xxxxxxxxxxxx"
  48.     }
  49.     r = requests.post(url, json=body_data)
  50.     print("编辑主题：", r.status_code, r.json())
  53. def test_collect_topic():
  54.     """
  55.     收藏话题
  56.     :return:
  57.     """
  58.     url = baseurl + "/topic_collect/collect"
  59.     body_data = {
  60.         "accesstoken": token,
  61.         # "topic_id":"625cc91ceb0fc111c4a0d584"
  62.         "topic_id": test_data["topic_id"]
  63.     }
  64.     r = requests.post(url, json=body_data)
  65.     print("收藏主题：", r.status_code, r.json())
  67. def test_uncollect_topic():
  68.     """
  69.     取消收藏
  70.     :return:
  71.     """
  72.     url = baseurl + "/topic_collect/de_collect"
  73.     body_data = {
  74.         "accesstoken": token,
  75.         # "topic_id": "625cc91ceb0fc111c4a0d584"
  76.         "topic_id": test_data["topic_id"]
  77.     }
  78.     r = requests.post(url, json=body_data)
  79.     print("取消主题：", r.status_code, r.json())
  81. def test_reply_topic():
  82.     """
  83.     评论话题
  84.     :return:
  85.     """
  86.     url = baseurl + "/topic/625cc91ceb0fc111c4a0d584/replies"
  87.     body_data = {
  88.         "accesstoken": token,
  89.         "content": "helloworld"
  90.     }
  91.     r = requests.post(url, json=body_data)
  92.     print("新建评论：", r.status_code, r.json())
  93.     # 从结果中提取 评论id
  94.     rid = r.json()["reply_id"]
  95.     # 将提取到的值更新到字典中
  96.     test_data["reply_id"] = rid
  98. def test_up():
  99.     """
  100.     点赞
  101.     :return:
  102.     """
  103.     # url = baseurl + "/reply/625cca2ceb0fc111c4a0d5e4/ups"
  104.     # 引用变量
  105.     url = baseurl + f'/reply/{test_data["reply_id"]}/ups'
  106.     body_data = {
  107.         "accesstoken": token
  108.     }
  109.     r = requests.post(url, json=body_data)
  110.     print("为评论点赞：", r.status_code, r.json())
  113. if __name__ == '__main__':
  114.     print("现在开始进行cnode社区主要接口流程测试：")
  115.     test_add_topic()
  116.     test_edit_topic()
  117.     test_collect_topic()
  118.     test_uncollect_topic()
  119.     test_reply_topic()
  120.     test_up()

新丰商城中接口串联

  1. # 导入生成的手机号
  2. from common.utils import generate_phone
  3. import requests
  4. # 1. 设置手机号 后面函数中使用手机号 都从这里获取
  5. phone = generate_phone()
  6. # 定义字典
  7. test_data = {
  8.     "token":None,  # 存放token
  9.     "goodsid":None
  10. }
  12. # 用户注册
  13. def test_register():
  14.     url = "http://49.233.108.117:28019/api/v1/user/register"
  15.     body_data = {
  16.         "loginName": phone,
  17.         "password": "123456"
  18.     }
  19.     print(f"使用数据进行注册：{body_data}")
  20.     r = requests.post(url,json=body_data)
  21.     # 打印请求的信息头
  22.     print("注册的请求头", r.request.headers)
  23.     # 打印返回结果
  24.     print("注册结果", r.json())
  26. # 用户登录
  27. def test_login():
  28.     url = "http://49.233.108.117:28019/api/v1/user/login"
  29.     body_data = {
  30.       "loginName": phone,
  31.       "passwordMd5": "E10ADC3949BA59ABBE56E057F20F883E"
  32.     }
  33.     print(f'使用数据进行登录 {body_data}')
  34.     r = requests.post(url,json=body_data)
  35.     # 打印出响应状态码 服务器返回结果
  36.     print("登录结果返回结果",r.status_code,r.json())
  37.     # 登陆成功 之后将token 设置变量 r.json()["data"] 返回结果中的token值
  38.     test_data["token"] = r.json()["data"]  # 更改testdata["token"] 的值
  40. def test_search():
  41.     url = "http://49.233.108.117:28019/api/v1/search"
  42.     query_data={
  43.         "keyword":"iphone"
  44.     }
  45.     token_header={
  46.         "token": test_data["token"] # 引用testdata["token"] 值
  47.     }
  48.     print('查询结果中的请求头',token_header)
  49.     r = requests.get(url,params=query_data,headers=token_header)
  50.     print('查询结果: ',r.json())
  52. if __name__ == '__main__':
  53.     # 注册和登录的时候需要使用到同一个手机号码
  54.     test_register()
  55.     test_login()
  56.     test_search()

其他上下游传参方式

使用return返回值

  1. # 随机函数
  2. import random
  3. # # 定义字典  可以通过修改 key 对应的value
  4. # data = {
  5. #     "rn": 0
  6. # }
  9. def f1():
  10.     # 随机生成一个数字
  11.     num = random.randint(1,100000)
  12.     # 修改字典中 rn字段的值
  13.     # data.append(num)
  14.     print(f'f1 生成随机数字 {num}')
  15.     return num
  17. def f2():
  18.     """
  19.     需要将 f1函数中生成 随机数字 传递过来，进行使用。
  20.     :return:
  21.     """
  22.     num = f1()
  23.     print(f'f2 使用f1生成的随机数字：{num}')
  25. def f3():
  26.     """
  27.     需要将 f1函数中生成 随机数字 传递过来，进行使用。
  28.     :return:
  29.     """
  30.     num = f1()
  31.     print(f'f3 使用f1生成的随机数字：{num}')
  33. if __name__ == '__main__':
  34.     f1()
  35.     f2()
  36.     f3()

通过return 返回值 也可以传参 但是f1会执行多次
image.png

使用global 关键字

global 可以将局部变量设置为全局变量

  1. # 随机函数
  2. import random
  4. def f1():
  5.     global num # 将局部变量设置全局变量
  6.     # 随机生成一个数字
  7.     num = random.randint(1,100000)
  9.     print(f'f1 生成随机数字 {num}')
  12. def f2():
  13.     """
  14.     需要将 f1函数中生成 随机数字 传递过来，进行使用。
  15.     :return:
  16.     """
  17.     print(f'f2 使用f1生成的随机数字：{num}')
  20. if __name__ == '__main__':
  21.     f1()
  22.     f2()

image.png
global 可以将局部变量设置为全局变量。
缺点就是 你在写代码引用变量的时候，不会有代码提示, 容易写错。

通过文件存储

将参数写入文件中。

  1. # 随机函数
  2. import random
  4. def f1():
  5.     # 随机生成一个数字
  6.     num = random.randint(1,100000)
  7.     # 将数据写入到 文件中
  8.     with open('./data.txt',mode='w') as file:
  9.         file.write(str(num))
  10.     print(f'f1 生成随机数字 {num}')
  13. def f2():
  14.     """
  15.     需要将 f1函数中生成 随机数字 传递过来，进行使用。
  16.     :return:
  17.     """
  18.     with open('./data.txt',mode='r') as file:
  19.         num = file.read()
  20.     print(f'f2 使用f1生成的随机数字：{num}')
  23. if __name__ == '__main__':
  24.     f1()
  25.     f2()

这样做 每次都要读写文件 比较麻烦。