postman脚本语法大全，不包括插件语法

官方语法例子：https://learning.postman.com/docs/writing-scripts/script-references/test-examples/

官方语法库：https://www.chaijs.com/api/bdd/

官方动态变量库：Dynamic variables | Postman Learning Center

一、基础语法使用

变量生效顺序，本地变量》迭代变量》环境变量》集合变量》全局变量,具有最接近作用域的变量将覆盖任何其他变量

1、pm.variables：操作变量

 //括号里”变量名“必须是字符串，下面的变量名都是如此
pm.variables.has("变量名")   //是否存在该变量，返回是boolean类型
pm.variables.get(”变量名“)   //获取该变量的值
pm.variables.set(”变量名“, 任意类型的变量值)  //设置变量
pm.variables.replaceIn(”变量名“)  //返回脚本中动态变量的值
pm.variables.toObject()  //返回一个对象，其中包含当前作用域中所有变量及其值。根据优先级顺序，这将包含来自多个作用域的变量。

2、pm.envrionment：操作环境变量

pm.environment.nam //获取当前活动的环境名字
pm.environment.has("变量名")   //是否存在该环境变量，返回是boolean类型
pm.environment.get(”变量名“)   //获取该环境变量的值
pm.environment.set(”变量名“, 任意类型的变量值)  //设置环境变量
pm.environment.unset(”变量名“)  //删除该环境变量
pm.environment.clear()   //清除所有环境变量
pm.environment.replaceIn(”变量名“)  //返回脚本中动态变量的值
pm.environment.toObject()  //返回一个对象，其中包含当前作用域中所有变量及其值。根据优先级顺序，这将包含来自多个作用域的变量。

3、pm.collectionVariables：操作集合变量

pm.collectionVariables.has("变量名")   //是否存在该集合变量，返回是boolean类型
pm.collectionVariables.get(”变量名“)   //获取该集合变量的值
pm.collectionVariables.set(”变量名“, 任意类型的变量值)  //设置集合变量
pm.collectionVariables.unset(”变量名“)  //删除该集合变量
pm.collectionVariables.clear()   //清除所有集合变量
pm.collectionVariables.replaceIn(”变量名“)  //返回脚本中动态变量的值
pm.collectionVariables.toObject()  //返回一个对象，其中包含当前作用域中所有变量及其值。根据优先级顺序，这将包含来自多个作用域的变量。

4、pm.globals：操作全局变量

pm.globals.has("变量名")   //是否存在该全局变量，返回是boolean类型
pm.globals.get(”变量名“)   //获取该全局变量的值
pm.globals.set(”变量名“, 任意类型的变量值)  //设置全局变量
pm.globals.unset(”变量名“)  //删除该全局变量
pm.globals.clear()   //清除所有全局变量
pm.globals.replaceIn(”变量名“)  //返回脚本中动态变量的值
pm.globals.toObject()  //返回一个对象，其中包含当前作用域中所有变量及其值。根据优先级顺序，这将包含来自多个作用域的变量。

5、pm.iterationData：操作迭代变量

pm.iterationData .has("变量名")   //是否存在该迭代变量，返回是boolean类型
pm.iterationData .get(”变量名“)   //获取该迭代变量的值
pm.iterationData.unset(”变量名“)  //删除迭代变量
pm.iterationData .toJSON(”变量名“)  //将 iterationData 对象转换为 JSON 格式
pm.iterationData .toObject()  //返回一个对象，其中包含当前作用域中所有变量及其值。根据优先级顺序，这将包含来自多个作用域的变量。

6、pm.request：操作请求数据

pm.request.url
pm.request.headers
pm.request.method
pm.request.body
pm.request.headers.add(header:Header)
pm.request.headers.remove(headerName:String)
pm.request.headers.upsert({key: headerName:String, value: headerValue:String}) //更新现有headernanme的字段值

7、pm.respnose：操作响应数据

pm.response.code
pm.response.status
pm.response.headers
pm.response.responseTime
pm.response.responseSize
pm.response.text():Function → String
pm.response.json():Function → Object

8、pm.info：操作当前事件信息输出

pm.info.eventName  //放在Test里就显示”test“，在Pre-request就显示”pre-request“
pm.info.iteration  //当前迭代的变量值
pm.info.iterationCount //该请求或者集合计划迭代的次数
pm.info.requestName  //正在运行的请求名称
pm.info.requestId  //正在运行的请求的唯一 GUID

9、pm.cookies：操作cookie

pm.cookies.has(cookieName:String):Function → Boolean
pm.cookies.get(cookieName:String):Function → String
pm.cookies.toObject():Function → Object

使用指定用于访问请求 Cookie 的域。pm.cookies.jar
pm.cookies.jar():Function → Object
//使用名称和值设置 Cookie：
jar.set(URL:String, cookie name:String, cookie value:String, callback(error, cookie)):Function → Object

//使用PostmanCookie或兼容对象设置 Cookie
jar.set(URL:String, { name:String, value:String, httpOnly:Bool }, callback(error, cookie)):Function → Object
例如：
const jar = pm.cookies.jar();
jar.set("httpbin.org", "session-id", "abc123", (error, cookie) => {
  if (error) {
    console.error(`An error occurred: ${error}`);
  } else {
    console.log(`Cookie saved: ${cookie}`);
  }
});

//获取cookie
jar.get(URL:String, cookieName:String, callback (error, value)):Function → Object

//获取所有cookie
jar.getAll(URL:String, callback (error, cookies)):Function

//删除cookie
jar.unset(URL:String, token:String, callback(error)):Function → Object

//清除cookie
jar.clear(URL:String, callback (error)):Function → Object

10、pm.sendRequest：可以使用该方法从预请求或测试脚本异步发送请求

// Example with a plain string URL
pm.sendRequest('https://postman-echo.com/get', (error, response) => {
  if (error) {
    console.log(error);
  } else {
  console.log(response);
  }
});

// Example with a full-fledged request
const postRequest = {
  url: 'https://postman-echo.com/post',
  method: 'POST',
  header: {
    'Content-Type': 'application/json',
    'X-Foo': 'bar'
  },
  body: {
    mode: 'raw',
    raw: JSON.stringify({ key: 'this is json' })
  }
};
pm.sendRequest(postRequest, (error, response) => {
  console.log(error ? error : response.json());
});

// Example containing a test
pm.sendRequest('https://postman-echo.com/get', (error, response) => {
  if (error) {
    console.log(error);
  }

  pm.test('response should be okay to process', () => {
    pm.expect(error).to.equal(null);
    pm.expect(response).to.have.property('code', 200);
    pm.expect(response).to.have.property('status', 'OK');
  });
});

11、postman.setNextRequest：设置集合工作流，在当前请求之后运行指定的请求（集合中定义的请求名称，例如"获取客户"）

//通过请求名字或者请求ID进行下一步的请求
postman.setNextRequest(requestName:String):Function
postman.setNextRequest(requestId:String):Function
//停止工作流
postman.setNextRequest(null);

12、脚本可视化

pm.visualizer.set(layout:String, data:Object, options:Object):Function  //layout必选，其他两个参数自选
//例子
var template = `<p>{{res.info}}</p>`;
pm.visualizer.set(template, {
    res: pm.response.json()
});

pm.getData(callback):Function  //用于检索可视化模板字符串中的响应数据
//例子
pm.getData(function (error, data) {
  var value = data.res.info;
});
//回调函数接受error和data两个参数，error传递任何错误信息，data传递数据到pm.visualizer.set

13、pm.test：断言

测试检查响应是否有效
pm.test("response should be okay to process", function () {
  pm.response.to.not.be.error;
  pm.response.to.have.jsonBody('');
  pm.response.to.not.have.jsonBody('error');
});

可选的回调可以传递给 ，以测试异步函数
pm.test('async test', function (done) {
  setTimeout(() => {
    pm.expect(pm.response.code).to.equal(200);
    done();
  }, 1500);
});

pm.test.index():Function → Number  //在代码中获取从特定位置执行的测试总数

二、断言和语法例子

输出变量值或者变量类型，打印日志

console.log(pm.collectionVariables.get("name"));
console.log(pm.response.json().name);
console.log(typeof pm.response.json().id);

if (pm.response.json().id) {
  console.log("id was found!");
  // do something
} else {
  console.log("no id ...");
  //do something else
}
//for循环读取
for（条件）{
语句;
}

状态码检测：

//pm.test.to.have方式
pm.test("Status code is 200", function () {
  pm.response.to.have.status(200);
});
//expect方式
pm.test("Status code is 200", () => {
  pm.expect(pm.response.code).to.eql(200);
});

多个断言作为单个测试的结果：

pm.test("The response has all properties", () => {
    //parse the response JSON and test three properties
    const responseJson = pm.response.json();
    pm.expect(responseJson.type).to.eql('vip');
    pm.expect(responseJson.name).to.be.a('string');
    pm.expect(responseJson.id).to.have.lengthOf(1);
});

不同类型的返回结果解析

//获取返回的json数据
const responseJson = pm.response.json();
//将number转换为JSON格式
JSON.stringify(pm.response.code)
//将json数据转换为数组
JSON.parse(jsondata)
//获取xml数据
const responseJson = xml2Json(pm.response.text());
//获取csv数据
const parse = require('csv-parse/lib/sync');
const responseJson = parse(pm.response.text());
//获取html数据
const $ = cheerio.load(pm.response.text());
//output the html for testing
console.log($.html());

直接处理未解析的返回数据，使用include

pm.test("Body contains string",() => {
  pm.expect(pm.response.text()).to.include("customer_id");
});

pm.test("Body is string", function () {
  pm.response.to.have.body("whole-body-text");
});

测试响应正文reponseBody中的特定值

pm.test("Person is Jane", () => {
  const responseJson = pm.response.json();
  pm.expect(responseJson.name).to.eql("Jane");
  pm.expect(responseJson.age).to.eql(23);
});
//获取响应正文
responseBody
pm.response.text()

测试某个值是否为集合中的一种，使用oneof

pm.test("Successful POST request", () => {
  pm.expect(pm.response.code).to.be.oneOf([201,202]);
});

测试响应header

//测试响应头是否存在
pm.test("Content-Type header is present", () => {
  pm.response.to.have.header("Content-Type");
});
//测试响应头的特定值
pm.test("Content-Type header is application/json", () => {
  pm.expect(pm.response.headers.get('Content-Type')).to.eql('application/json');
});

//获取响应头”Server“数据

  postman.getResponseHeader("Server")

测试cookie

//测试是否存在相应的cookie
pm.test("Cookie JSESSIONID is present", () => {
  pm.expect(pm.cookies.has('JSESSIONID')).to.be.true;
});
//测试该cookie是否等于特定值
pm.test("Cookie isLoggedIn has value 1", () => {
  pm.expect(pm.cookies.get('isLoggedIn')).to.eql('1');
});

测试响应时间是否在范围内，使用below

pm.test("Response time is less than 200ms", () => {
  pm.expect(pm.response.responseTime).to.be.below(200);
});

测试reponsebody中某个值和某个变量的值一致

pm.test("Response property matches environment variable", function () {
pm.expect(pm.response.json().name).to.eql(pm.environment.get("name"));
});

测试响应数据的类型

/* response has this structure:
{
  "name": "Jane",
  "age": 29,
  "hobbies": [
    "skating",
    "painting"
  ],
  "email": null
}
*/
const jsonData = pm.response.json();
pm.test("Test data type of the response", () => {
  pm.expect(jsonData).to.be.an("object");
  pm.expect(jsonData.name).to.be.a("string");
  pm.expect(jsonData.age).to.be.a("number");
  pm.expect(jsonData.hobbies).to.be.an("array");
  pm.expect(jsonData.website).to.be.undefined;
  pm.expect(jsonData.email).to.be.null;
});

测试数据为空，或者包含特定项

/*
response has this structure:
{
  "errors": [],
  "areas": [ "goods", "services" ],
  "settings": [
    {
      "type": "notification",
      "detail": [ "email", "sms" ]
    },
    {
      "type": "visual",
      "detail": [ "light", "large" ]
    }
  ]
}
*/

const jsonData = pm.response.json();
pm.test("Test array properties", () => {
    //errors array is empty
  pm.expect(jsonData.errors).to.be.empty;
    //areas includes "goods"
  pm.expect(jsonData.areas).to.include("goods");
    //get the notification settings object
  const notificationSettings = jsonData.settings.find(m => m.type === "notification");
  pm.expect(notificationSettings).to.be.an("object", "Could not find the setting");
    //detail array should include "sms"
  pm.expect(notificationSettings.detail).to.include("sms");
    //detail array should include all listed
  pm.expect(notificationSettings.detail).to.have.members(["email", "sms"]);
});

断言对象包含键、属性

pm.expect({a: 1, b: 2}).to.have.all.keys('a', 'b');
pm.expect({a: 1, b: 2}).to.have.any.keys('a', 'b');
pm.expect({a: 1, b: 2}).to.not.have.any.keys('c', 'd');
pm.expect({a: 1}).to.have.property('a');
pm.expect({a: 1, b: 2}).to.be.an('object').that.has.all.keys('a', 'b');

断言值为父对象的一部分，使用deep，数据里嵌套的数据不会被检查到

/*
response has the following structure:
{
  "id": "d8893057-3e91-4cdd-a36f-a0af460b6373",
  "created": true,
  "errors": []
}
*/

pm.test("Object is contained", () => {
  const expectedObject = {
    "created": true,
    "errors": []
  };
  pm.expect(pm.response.json()).to.deep.include(expectedObject);
});

断言选定的测试活动环境

pm.test("Check the active environment", () => {
  pm.expect(pm.environment.name).to.eql("Production");
});

断言响应结构

const schema = {
 "items": {
 "type": "boolean"
 }
};
const data1 = [true, false];
const data2 = [true, 123];

pm.test('Schema is valid', function() {
  pm.expect(tv4.validate(data1, schema)).to.be.true;
  pm.expect(tv4.validate(data2, schema)).to.be.true;
});

常见断言错误分析

//问题：AssertionError: expected <value> to deeply equal '<value>'
//原因：相比较的双方类型不一致导致，如字符串和数字对比
pm.expect(1).to.eql("1");    //例子

//问题：ReferenceError: jsonData is not defined
//原因：引用尚未声明或超出测试代码范围的 JSON 对象时，通常会发生这种情况

pm.test("Test 1", () => {
  const jsonData = pm.response.json();
  pm.expect(jsonData.name).to.eql("John");
});  //正确操作例子
pm.test("Test 2", () => {
  pm.expect(jsonData.age).to.eql(29); // jsonData is not defined
});  //错误操作例子

//问题：AssertionError: expected undefined to deeply equal..
//原因：断言的属性未定义错误

pm.expect(jsonData.name).to.eql("John"); //该jsonData.name未被定义，出现AssertionError: expected undefined to deeply equal 'John'namejsonData

发送异步请求

pm.sendRequest("https://postman-echo.com/get", function (err, response) {
    console.log(response.json());
});