0
0

postman变量和脚本功能介绍

1、基本概念——global、collection、environment

在postman中，为了更好的管理各类变量、测试环境以及脚本等，创建了一些概念，包括：globals、collection、environment。其实在postman中，最上层还有一个Workspaces的概念，不过大多数情况我们都使用一个workspace，这里就不多介绍了。

1.1）请求组（collection）：

可以将多个请求保存到一个请求组(Collections)中, 好处是: 增加额外Collection变量作用域, 增加公共的PreRequest和Test脚本, 批量执行Collection下的请求, 定义Collection内请求的顺序。

上图中可以看到，左上角“+”可以创建新的collection；点击collection的右侧“。。。”可以Edit现有collection，以及Run、Add folder等功能。

说明：Collection下还可以建文件夹，对请求进一步划分，比如：用户模块、订单模块。

1.2）环境（environment）：

通常一个系统具备多个环境，比如：测试、线上。

如上图，点击左上角“+”可以新建一个environment；鼠标指向现有environment，点击右侧“。。。”可以进行编辑。值得提醒的是，当运行时，需要在右上角选中我们想要的环境。

变量有两个value（不光是环境变量，其他变量也是一样的），二者的区别：

  • INITAL_VALUE：初始值是在定义变量的元素（集合、环境或全局变量）中设置的值。此值将同步到 Postman 的服务器，并在您共享该元素时与您的团队共享
  • CURRENT_VALUE：这些是本地值，不会同步到 Postman 的服务器。如果您更改当前值，它将不会保留在原始共享集合、环境或全局变量中。

1.3）golbal：

细心的朋友已经发现，在environment中，左上角出现了Golbals：

2、变量

变量，在postman中最常见的一个功能，包括设置、读取、作用域等。

2.1）变量作用域：

postman中变量有多个作用域, 越往内的作用域优先级越高(global < collection < environment < …), 举例来说, 如果global作用域和Environment作用域里都有一个变量叫username, 那么最终使用的是Environment作用域里的变量值。

不同作用域变量设置方法：

2.2）定义、使用变量

从上面图可以看到，在UI界面上可以管理globals变量，后面也会降到使用API方式设置、读取globes变量（会同步出现在UI界面上）；同样的，对于environment变量也是一样的。（如上面1.2和1.3）

1）通过界面定义变量：

选中某个值，然后点击弹出的菜单点击"Set as new variable"：

然后这只变量名、和作用域：

2）管理Collections变量：

选择某个Collection后，点击右侧的“。。。”，然后选择Edit，在右侧界面上会显示Variables。

3）使用变量：

在不同作用域定义好变量后, 然后在某个请求中引用该变量, 从而做到变量复用和统一管理。

使用"{{变量名}}"来引用变量。

2.3）在脚本中操作变量

  1. // 不同作用域设置变量
  2. pm.globals.set("username", "golbals_name");
  3. pm.globals.set("username1", "golbals_name1");
  4. pm.collectionVariables.set("username", "collection_name");
  5. pm.environment.set("username", "environment_name");
  6. pm.variables.set("username", "variable_username"); //临时覆盖, 优先级最高, 请求结束后失效
  8. // 获取变量值
  9. console.log(pm.globals.get("username")); //从globals作用域中查询变量
  10. console.log(pm.collectionVariables.get("username"));
  11. console.log(pm.environment.get("username"));
  12. var k = pm.variables.get("username1"); //依次从各个作用域查找
  13. console.log("username:" + k);
  15. // 判断
  16. pm.variables.has("username");
  17. pm.environment.has("username");
  18. pm.globals.has("username");
  20. // 清理
  21. pm.environment.unset("username");

2.4）data作用域的变量

在UI界面上，选择Collection的Run，在界面中可以选择一个文件

然后准备一个文件，内容如下：（必须是json或者csv格式）

  1. [{
  2.   "path": "post",
  3.   "value": "1"
  4. }, {
  5.   "path": "post",
  6.   "value": "2"
  7. }, {
  8.   "path": "post",
  9.   "value": "3"
  10. }, {
  11.   "path": "post",
  12.   "value": "4"
  13. }]

另外，在脚本里访问data文件可以使用如下AIP：

  1. pm.iterationData.get("value");

3、脚本

postman API文档：Home - Postman Documentation

3.1）脚本相关概念：

1）脚本执行顺序：

执行每个请求时会依次执行如下脚本:

  1. Collection级别的pre-request脚本
  2. Folder级别的pre-request脚本
  3. Request级别的pre-prequest脚本
  4. Request级别的test脚本
  5. Folder级别的test脚本
  6. Collection级别的test脚本

2）在界面上输入脚本信息：

最常见的就是request级别的脚本，可以在Scripts页签下输入，如下：

可以看到，脚本分两个：pre-request和post-reponse，分别对应请求前处理和请求后处理。

在Collection级别上也可以创建脚本，如下：

同样，如果在Collection下有folder，那么folder上也可以创建scripts。

3.2）常用脚本代码

1）操作变量：

  1. // 设置全局变量
  2. pm.globals.set('variable_key', 'variable_value');
  3. var variable_key = pm.globals.get('variable_key');// 获取全局变量
  4. pm.globals.unset('variable_key');// unset 全局变量
  6. // 设置环境变量
  7. pm.environment.set('variable_key', 'variable_value');
  8. var variable_key = pm.environment.get('variable_key');// 获取环境变量
  9. pm.environment.unset('variable_key');// unset 环境变量
  11. // 设置临时变量
  12. pm.variables.set('variable_key', 'variable_value');
  13. var variable_key = pm.variables.get('variable_key');// 获取临时变量
  14. pm.variables.unset('variable_key');// unset 临时变量
  16. // 将对象或数组（非字符串）写入环境变量
  17. var array = [1, 2, 3, 4];
  18. pm.environment.set('array', JSON.stringify(array));
  19. var obj = { a: [1, 2, 3, 4], b: { c: 'val' } };
  20. pm.environment.set('obj', JSON.stringify(obj));
  21. // 转换回来
  22. try {
  23.   var array = JSON.parse(pm.environment.get('array'));
  24.   var obj = JSON.parse(pm.environment.get('obj'));
  25. } catch (e) {
  26.   // 处理异常
  27. }

2）前置读取/修改接口信息：

  1. // ================= URL ===================
  2. // 获取 url 对象
  3. var urlObject = pm.request.url;
  5. // 获取完整接口请求 URL，包含 query 参数
  6. var url = urlObj.toString();
  8. // 获取协议（http 或 https）
  9. var protocol = urlObj.protocol;
  11. // 获取 端口
  12. var port = urlObj.port;
  14. // ================= Header ===================
  15. // 获取 Header 参数对象
  16. var headers = pm.request.headers;
  18. // 获取 key 为 field1 的 header 参数的值
  19. var field1 = headers.get('field1');
  21. // 已键值对象方式获取所有 query 参数
  22. var headersObject = headers.toObject();
  24. // 遍历整个 query
  25. headers.each(item => {
  26.     console.log(item.key); // 输出参数名
  27.     console.log(item.value); // 输出参数值
  28. });
  30. // 增加 header 参数
  31. headers.add({
  32.     key: 'field1',
  33.     value: 'value1',
  34. });
  36. // 修改 query 参数（如不存在则新增）
  37. headers.upsert({
  38.     key: 'field2',
  39.     value: 'value2',
  40. });
  42. // ================= Query ===================
  43. // 获取 Query 参数对象
  44. var queryParams = pm.request.url.query;
  46. // 获取 key 为 field1 的 query 参数的值
  47. var field1 = queryParams.get('field1');
  49. // 已键值对象方式获取所有 query 参数
  50. var quertParamsObject = queryParams.toObject();
  52. // 遍历整个 query
  53. queryParams.each(item => {
  54.     console.log(item.key); // 输出参数名
  55.     console.log(item.value); // 输出参数值
  56. });
  58. // 增加 query 参数
  59. queryParams.add({
  60.     key: 'field1',
  61.     value: 'value1',
  62. });
  64. // 修改 query 参数（如不存在则新增）
  65. queryParams.upsert({
  66.     key: 'field2',
  67.     value: 'value2',
  68. });
  70. // ================= Body ===================
  71. // Body 参数来自pm.request.body，pm.request.body 是一个RequestBody 实例。
  72. // Body 参数在只能读取，不能直接修改。如需修改 Body 里的数据，请在 Body 里引用变量，然后在脚本里设置变量的值，以达到修改的目的。
  74. // --------------------- body 类型为 form-data ------------------
  75. // 当 body 类型为 form-data 时，从 pm.request.body.formdata 获取请求参数
  76. var formData = pm.request.body.formdata;
  78. // 获取 key 为 field1 的 form-data 参数的值
  79. var field1 = formData.get('field1');
  80. console.log(field1); // 控制台打印 field1
  82. // 已键值对象方式获取所有 formdata 参数
  83. var formdataObject = formData.toObject();
  84. console.log(formdataObject); // 控制台打印 formdataObject
  86. // 遍历整个 form-data 数据
  87. formData.each(item => {
  88.     console.log(item.key); // 控制台打印参数名
  89.     console.log(item.value); // 控制台打印参数值
  90. });
  92. // --------------------- body 类型为 x-www-form-urlencode ------------------
  93. // 当 body 类型为 x-www-form-urlencode** 时，从 pm.request.body.urlencoded 获取请求参数
  94. var formData = pm.request.body.urlencoded;
  96. // 获取 key 为 field1 的 form-data 参数的值
  97. var field1 = formData.get('field1');
  99. // 已键值对象方式获取所有 formdata 参数
  100. var formdataObject = formData.toObject();
  102. // 遍历整个 form 数据
  103. formData.each(item => {
  104.     console.log(item.key); // 控制台打印参数名
  105.     console.log(item.value); // 控制台打印参数值
  106. });
  108. // --------------------- body 类型为 JSON ------------------
  109. try {
  110.     var jsonData = JSON.parse(pm.request.body.raw);
  111.     console.log(jsonData); // 控制台打印参整个 json 数据
  112. } catch (e) {
  113.     console.log(e);
  114. }
  116. // --------------------- body 类型为 raw ------------------
  117. var raw = pm.request.body.raw;
  118. console.log(raw); // 控制台打印参整个 raw 数据

3）常用后置脚本：

  1. pm.test("响应状态码为200", function () {
  2.   pm.response.to.have.status(200);
  3.   pm.expect(pm.response.code).to.eql(200);
  4. });
  6. // GET https://gank.io/api/v2/banners
  7. pm.test("成功响应且有数据", function() {
  8.     pm.expect(pm.response.code).to.eql(200);
  10.     const respJson = pm.response.json();
  11.     pm.expect(respJson.data).to.length.gt(0);
  12. })
  14. // GET https://gank.io/api/v2/data/category/GanHuo/type/iOS/page/1/count/10
  15. pm.test("分页数据满页", function() {
  16.     const respJson = pm.response.json();
  17.     pm.expect(respJson.data.length).to.eq(10);
  18.     pm.expect(respJson.data).to.have.lengthOf(10);
  19. })
  21. // 在脚本中发送请求
  22. pm.sendRequest("https://gank.io/api/v2/banners", function(err, resp) {
  23.     console.log(resp.json())
  24. })
  26. // 响应数据转换
  27. // json
  28. const responseJson = pm.response.json();
  29. // xml
  30. const responseJson = xml2Json(pm.response.text());
  31. // csv
  32. const parse = require('csv-parse/lib/sync');
  33. const responseJson = parse(pm.response.text());
  34. // html https://cheerio.js.org
  35. const $ = cheerio.load(pm.response.text());
  36. console.log($.html());
  37. console.log($(".header"));
  38. // 纯文本
  39. pm.expect(pm.response.text()).to.include("customer_id");
  40. pm.response.to.have.body("whole-body-text");
  42. // 将 jsonData.token 的值写入环境变量
  43. pm.environment.set('token', jsonData.token);

4）常用断言：

  1. // response assertions 示例
  2. pm.test('返回结果没有错误', function() {
  3.   pm.response.to.not.be.error;
  4.   pm.response.to.have.jsonBody('');
  5.   pm.response.to.not.have.jsonBody('error');
  6. });
  8. // pm.response.to.be* 示例
  9. pm.test('返回结果没有错', function() {
  10.   // assert that the status code is 200
  11.   pm.response.to.be.ok; // info, success, redirection, clientError,  serverError, are other variants
  12.   // assert that the response has a valid JSON body
  13.   pm.response.to.be.withBody;
  14.   pm.response.to.be.json; // this assertion also checks if a body  exists, so the above check is not needed
  15. });
  17. // -----------  状态码  -------------
  18. pm.test('Status code is 200', function() {
  19.   pm.response.to.have.status(200);
  20. });
  21. // 检查 HTTP 状态码名称是否包含某个字符串
  22. pm.test('Status code name has string', function() {
  23.   pm.response.to.have.status('Created');
  24. });
  25. // 是否正确的 POST 请求状态码
  26. pm.test('Successful POST request', function() {
  27.   pm.expect(pm.response.code).to.be.oneOf([201, 202]);
  28. });
  30. // --------- 请求头  ---------
  31. pm.expect(pm.response.headers.get('Content-Type')).to.eql('application/json');
  32. pm.test('Content-Type header is present', function() {
  33.   pm.response.to.have.header('Content-Type');
  34. });
  36. // ---------  cookie  ---------
  37. pm.expect(pm.cookies.has('JSESSIONID')).to.be.true;
  38. pm.expect(pm.cookies.get('isLoggedIn')).to.eql('1');
  40. // ---------  响应时间 ms  ---------
  41. pm.test('Response time is less than 200ms', function() {
  42.   pm.expect(pm.response.responseTime).to.be.below(200);
  43. });
  45. // ---------------  请求体验证  -----------------
  46. const jsonData = pm.response.json();
  47. pm.expect(jsonData.name).to.eql("Jane");
  48. // 响应值等于某个预先定义的变量值
  49. pm.expect(jsonData.name).to.eql(pm.environment.get("name"));
  51. // 检查 response body 是否包含某个字符串
  52. pm.test('Body matches string', function() {
  53.   pm.expect(pm.response.text()).to.include('string_you_want_to_search');
  54. });
  56. // 检查 response body 是否包含等于字符串
  57. pm.test('Body is correct', function() {
  58.   pm.response.to.have.body('response_body_string');
  59. });
  61. // 检查 json 值
  62. pm.test('Your test name', function() {
  63.   var jsonData = pm.response.json();
  64.   pm.expect(jsonData.value).to.eql(100);
  65. });
  67. // 断言数据类型
  68. pm.expect(jsonData).to.be.an("object");
  69. pm.expect(jsonData.name).to.be.a("string");
  70. pm.expect(jsonData.age).to.be.a("number");
  71. pm.expect(jsonData.hobbies).to.be.an("array");
  72. pm.expect(jsonData.website).to.be.undefined;
  73. pm.expect(jsonData.email).to.be.null;
  75. // 数组属性
  76. pm.expect(jsonData.errors).to.be.empty;
  77. pm.expect(jsonData.errors).to.be.an('array').that.is.empty;
  78. pm.expect(jsonData.areas).to.include("goods");
  79. const contactSettings = jsonData.settings.find(m => m.type === "contact");
  80. pm.expect(contactSettings).to.be.an("object", "找不到联系方式配置信息");
  81. pm.expect(contactSettings.detail).to.have.members(["email", "sms"]);
  83. // 对象
  84. pm.expect({a: 1, b: 2}).to.have.all.keys('a', 'b');
  85. pm.expect({a: 1, b: 2}).to.have.any.keys('a', 'b');
  86. pm.expect({a: 1, b: 2}).to.not.have.any.keys('c', 'd');
  87. pm.expect({a: 1}).to.have.property('a');
  88. pm.expect({a: 1, b: 2}).to.be.an('object').that.has.all.keys('a', 'b');
  89. pm.expect({a: 1, b: 2}).to.deep.include({a:1});    // 包含部分属性
  90. // 集合
  91. pm.expect({"a": 1, "b": 123}.a).to.be.oneOf([1, 123]);
  93. // 字符串
  94. pm.expect('').to.be.empty;

5）脚本里发送请求：

  1. pm.sendRequest('https://postman-echo.com/get', (error, response) => {
  2.   if (error) {
  3.     console.log(error);
  4.   } else {
  5.     console.log(response);
  6.     pm.environment.set('variable_key', 'new_value');
  7.   }
  8. });
  10. // 完整的 request 参数示例
  11. const echoPostRequest = {
  12.   url: 'https://postman-echo.com/post',
  13.   method: 'POST',
  14.   header: {
  15.     headername1: 'value1',
  16.     headername2: 'value2',
  17.   },
  18.   body: {
  19.     mode: 'raw',
  20.     raw: JSON.stringify({ key: 'this is json' }),
  21.   },
  22. };
  23. pm.sendRequest(echoPostRequest, function(err, res) {
  24.   console.log(err ? err : res.json());
  25. });
  27. // 对返回结果进行断言
  28. pm.sendRequest('https://postman-echo.com/get', function(err, res) {
  29.   if (err) {
  30.     console.log(err);
  31.   }
  32.   pm.test('response should be okay to process', function() {
  33.     pm.expect(err).to.equal(null);
  34.     pm.expect(res).to.have.property('code', 200);
  35.     pm.expect(res).to.have.property('status', 'OK');
  36.   });
  37. });

在Runner中运行collection下的请求时, 可以通过postman.setNextRequest(请求名) 或者 postman.setNextRequest(请求id)来指定下一个请求, 这样可以构建起一个调用工作流, 比如先请求数据列表接口, 然后从响应中获取数据id, 再请求数据详情接口.

原文：postman | Tonny's Blog

标签： postman 测试工具
本文转载自: https://blog.csdn.net/liuxiao723846/article/details/143695185
版权归原作者 赶路人儿 所有， 如有侵权，请联系我们删除。
登录后发布评论

“postman变量和脚本功能介绍”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。