关于PostMan中Tests脚本的使用-Toy模板网

这篇具有很好参考价值的文章主要介绍了关于PostMan中Tests脚本的使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

不得不说PostMan真的是一个强大的接口测试工具，深得人心。

小编也在闲暇之余整理了一些有关于PostMan中的Tests脚本的示例，希望能帮助到热爱学习热爱工作的各位。

状态码验证：

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

响应时间验证：

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

JSON 响应体验证：

pm.test("Response body has a valid key", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('keyName');
});

字符串匹配验证：

pm.test("Response body contains expected text", function () {
    pm.expect(pm.response.text()).to.include("expectedText");
});

数组长度验证

pm.test("Response body has an array with at least 3 elements", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.arrayProperty).to.have.lengthOf.at.least(3);
});

数据类型验证：

pm.test("Response body property has the correct data type", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyName).to.be.a('number');
});

头部信息验证

pm.test("Content-Type header is present", function () {
    pm.response.to.have.header("Content-Type");
});

环境变量验证：

pm.test("Environment variable has expected value", function () {
    pm.expect(pm.environment.get("variableName")).to.equal("expectedValue");
});

响应体 JSON Schema 验证：

pm.test("Response body follows JSON schema", function () {
    var jsonData = pm.response.json();
    var schema = {
        "type": "object",
        "properties": {
            "name": { "type": "string" },
            "age": { "type": "number" }
        },
        "required": ["name", "age"]
    };
    pm.expect(tv4.validate(jsonData, schema)).to.be.true;
});
//此示例使用 tv4 库进行 JSON Schema 验证。

多个条件的组合验证：

pm.test("Multiple conditions combined", function () {
    var jsonData = pm.response.json();

    // Check multiple conditions
    pm.expect(jsonData.property1).to.equal("expectedValue1");
    pm.expect(jsonData.property2).to.be.an('array').that.includes('expectedValue2');
    pm.expect(jsonData.property3).to.have.lengthOf.at.most(5);
});

日期格式验证：

pm.test("Date format is valid", function () {
    var jsonData = pm.response.json();
    var dateFormat = /\d{4}-\d{2}-\d{2}/; // Example: YYYY-MM-DD
    pm.expect(jsonData.dateProperty).to.match(dateFormat);
});

断言异常情况：有时，你可能需要验证 API 返回的错误状态。

pm.test("Check for an error response", function () {
    pm.expect(pm.response.json().status).to.equal("error");
});

验证数组元素

pm.test("All items in the array meet a certain condition", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.items).to.satisfy(function (items) {
        return items.every(function (item) {
            return item.property > 0;
        });
    });
});

验证响应头信息：

pm.test("Check for a specific header value", function () {
    pm.expect(pm.response.headers.get("Content-Type")).to.equal("application/json");
});

环境变量和全局变量的更新：可以根据 API 响应更新环境变量或全局变量，以便后续请求使用更新后的值

pm.test("Update environment variable based on response", function () {
    var jsonData = pm.response.json();
    pm.environment.set("variableName", jsonData.propertyToUpdate);
});

文件上传后的验证：如果你的 API 支持文件上传，可以验证上传操作是否成功

pm.test("Check if file upload was successful", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.status).to.equal("success");
    pm.expect(jsonData.uploadedFiles.length).to.be.above(0);
});

验证重定向：如果 API 返回了重定向响应，你可以验证重定向的状态码和目标地址。

pm.test("Check for a redirect", function () {
    pm.expect(pm.response.code).to.be.oneOf([301, 302]);
    pm.expect(pm.response.headers.get("Location")).to.equal("https://newlocation.com");
});

使用正则表达式进行文本匹配：使用正则表达式来验证响应体中的文本是否符合特定的模式。

pm.test("Check for a specific pattern in the response body", function () {
    pm.expect(pm.response.text()).to.match(/PatternToMatch/);
});

数据存在性验证：确保特定的键存在于响应体中。

pm.test("Check if specific data exists in the response", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.include.keys("expectedKey");
});

比较两个响应体

pm.test("Compare two response bodies", function () {
    var jsonData1 = pm.response.json();
    var jsonData2 = pm.iterationData.get("expectedResponse");
    pm.expect(jsonData1).to.eql(jsonData2);
});

验证响应时间是否在一定范围内：确保 API 的响应时间在预期的范围内。

pm.test("Response time is within an acceptable range", function () {
    pm.expect(pm.response.responseTime).to.be.within(100, 1000); // 100ms to 1000ms
});

验证响应头信息是否包含特定值：检查响应头信息中是否包含特定值。

pm.test("Check for a specific value in the response header", function () {
    pm.expect(pm.response.headers.get("Content-Type")).to.include("application/json");
});

验证响应体中数组元素的属性：遍历数组中的每个元素并验证其属性。

pm.test("Check properties of each item in the array", function () {
    var jsonData = pm.response.json();
    jsonData.forEach(function (item) {
        pm.expect(item).to.have.property("propertyName");
    });
});

验证响应体中对象的值是否满足条件：确保对象的属性值满足特定条件。

pm.test("Check if object properties meet certain conditions", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyName).to.satisfy(function (value) {
        return value > 0 && value < 100;
    });
});

使用外部库进行验证：如果需要进行更复杂的验证，你可以引入外部库并使用它来验证响应。

pm.test("Use external library for advanced validation", function () {
    var jsonData = pm.response.json();
    var isValid = externalLibrary.validate(jsonData);
    pm.expect(isValid).to.be.true;
});

测试脚本中的日志记录：在测试脚本中使用 console.log 记录信息，有助于调试和定位问题。

pm.test("Logging information for debugging", function () {
    var jsonData = pm.response.json();
    console.log("Response data:", jsonData);
    pm.expect(jsonData).to.have.property("expectedKey");
});

验证响应头信息中是否包含特定的 Cookie：

pm.test("Check for a specific cookie in the response headers", function () {
    pm.expect(pm.response.headers.has("Set-Cookie")).to.be.true;
});

使用 Chai 库进行更丰富的断言：如果你想使用更丰富的断言功能，可以结合 Chai 库使用。首先，在 Postman 的 "Pre-request Script" 或 "Tests" 中添加以下代码：
```
// 引入 Chai 库
var chai = require('chai');

// 使用 Chai 断言库的 BDD 风格
var expect = chai.expect;
```
然后，你可以在测试脚本中使用 Chai 提供的更多断言功能：使用 Chai 能够提供更多的断言选项和更清晰的测试语法。
```
pm.test("Use Chai for advanced assertions", function () {
    var jsonData = pm.response.json();

    // 使用 Chai 断言
    expect(jsonData).to.have.property("propertyName").that.is.a("string");
    expect(jsonData.arrayProperty).to.be.an("array").that.includes("expectedValue");
});
```

在循环中执行测试：在循环中执行测试，适用于需要对数组中的每个元素进行相同验证的情况。

pm.test("Loop through array elements for validation", function () {
    var jsonData = pm.response.json();

    // 假设 responseData 是一个数组
    jsonData.forEach(function (item) {
        pm.test("Check individual item", function () {
            pm.expect(item).to.have.property("property").that.is.a("string");
            // 添加更多的断言...
        });
    });
});

验证响应体是否符合 OpenAPI 规范：如果你有 OpenAPI 规范，可以使用相应的库验证响应是否符合规范。

pm.test("Validate response against OpenAPI specification", function () {
    var jsonData = pm.response.json();
    var openAPISpec = { /* Your OpenAPI specification here */ };
    var isValid = openAPISpecValidator.validate(jsonData, openAPISpec);
    pm.expect(isValid).to.be.true;
});

验证特定条件下的重定向：在某些情况下验证 API 返回的重定向。

pm.test("Check for redirect under specific conditions", function () {
    // 在特定条件下，期望 302 状态码和正确的 Location 头
    pm.expect(pm.response.code).to.equal(302);
    pm.expect(pm.response.headers.get("Location")).to.equal("https://redirectedlocation.com");
});

使用环境变量动态构建请求：

pm.test("Dynamically build request using environment variables", function () {
    var apiKey = pm.environment.get("api_key");
    var requestUrl = `https://api.example.com/data?apiKey=${apiKey}`;

    // 发送请求
    pm.sendRequest({
        url: requestUrl,
        method: 'GET',
        // 其他请求选项...
    }, function (err, response) {
        // 处理响应...
    });
});

验证响应体是否符合 JSON Schema：使用 Postman 的内置 JSON Schema 验证功能，确保响应体符合预期的 JSON Schema。

pm.test("Validate response against JSON Schema", function () {
    var jsonData = pm.response.json();
    var schema = {
        type: "object",
        properties: {
            key1: { type: "string" },
            key2: { type: "number" },
            key3: { type: "array" }
        },
        required: ["key1", "key2"]
    };
    pm.expect(jsonData).to.have.jsonSchema(schema);
});

验证日期的格式和范围：

pm.test("Validate date format and range", function () {
    var jsonData = pm.response.json();
    var dateFormat = /^\d{4}-\d{2}-\d{2}$/; // YYYY-MM-DD
    pm.expect(jsonData.date).to.match(dateFormat);
    pm.expect(new Date(jsonData.date)).to.be.within(new Date("2022-01-01"), new Date("2023-01-01"));
});

验证 JSON 响应体中的嵌套属性：用于验证 JSON 响应体中的嵌套属性。

pm.test("Check nested properties in JSON response", function () {
    var jsonData = pm.response.json();

    // 验证嵌套属性
    pm.expect(jsonData).to.have.nested.property("parentProperty.childProperty").that.is.a("string");
});

使用 Newman 运行 Postman 集合并生成报告：在 Postman 的 "Tests" 中使用 Newman 运行集合，并将结果保存为报告。

pm.test("Run collection using Newman", function () {
    pm.expect(pm.info.iteration).to.equal(1); // 只在第一次迭代运行

    // 构建 Newman 命令
    var newmanCommand = `newman run ${__ENV.PATH_TO_COLLECTION} --reporters cli,json --reporter-json-export ${__ENV.PATH_TO_REPORT}`;

    // 执行命令
    var commandOutput = exec(newmanCommand);

    // 打印 Newman 输出
    console.log(commandOutput);

    // 检查 Newman 是否成功运行
    pm.expect(commandOutput).to.include("run completed");
});

验证响应头信息中是否包含特定的值：检查响应头信息中是否包含特定的值，例如压缩编码方式。

pm.test("Check for a specific value in the response header", function () {
    pm.expect(pm.response.headers.get("Content-Encoding")).to.equal("gzip");
});

使用环境变量设置请求头信息：在测试脚本中使用环境变量设置请求头信息，适用于需要动态设置请求头的情况。

pm.test("Set request headers using environment variables", function () {
    var apiKey = pm.environment.get("api_key");
    pm.request.headers.upsert({ key: 'Authorization', value: `Bearer ${apiKey}` });
});

验证响应体中的时间戳是否有效：

pm.test("Check if timestamp in the response is valid", function () {
    var jsonData = pm.response.json();
    var timestamp = jsonData.timestamp;

    // 验证 timestamp 是否为有效的 Unix 时间戳
    pm.expect(timestamp).to.be.above(0);
});

使用 pm.response.to.be.* 进行更多的断言：Postman 提供了一组 pm.response.to.be.* 的断言，用于更方便的验证响应。

pm.test("Additional assertions using pm.response.to.be", function () {
    pm.response.to.be.ok; // 确保响应为真值
    pm.response.to.be.withBody; // 确保响应体存在
    pm.response.to.be.json; // 确保响应体为 JSON
    pm.response.to.be.header("Content-Type", "application/json"); // 确保 Content-Type 为 application/json
});

验证响应体中的日期格式：使用正则表达式验证响应体中的日期格式。

pm.test("Check if date in the response follows a specific format", function () {
    var jsonData = pm.response.json();
    var dateRegex = /^\d{4}-\d{2}-\d{2}$/; // 日期格式为 YYYY-MM-DD
    pm.expect(jsonData.date).to.match(dateRegex);
});

验证数组中元素的唯一性：确保数组中的元素是唯一的。

pm.test("Check if array elements are unique", function () {
    var jsonData = pm.response.json();
    var uniqueElements = new Set(jsonData.arrayProperty);
    pm.expect(uniqueElements.size).to.equal(jsonData.arrayProperty.length);
});

验证响应体中某个属性的值在一定范围内：验证响应体中某个属性的值是否在指定范围内。

pm.test("Check if property value is within a specific range", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyValue).to.be.within(1, 100);
});

在预期的响应时间内重试请求：在测试脚本中使用 pm.sendRequest 来重试请求，直到满足预期的响应时间条件。

// 在 "Tests" 脚本中使用 pm.sendRequest 重试请求，直到响应时间在指定范围内
pm.test("Retry request until response time is within expected range", function () {
    var maxRetryCount = 5;
    var expectedResponseTime = 200; // 期望的响应时间

    pm.sendRequest(function () {
        return {
            url: pm.request.url,
            method: pm.request.method,
            header: pm.request.headers,
            body: pm.request.body
        };
    }, function (err, response) {
        pm.expect(response.responseTime).to.be.below(expectedResponseTime);

        if (response.responseTime > expectedResponseTime && pm.iteration < maxRetryCount) {
            // 重试请求
            return true;
        }
    });
});

验证响应体中的属性值是否满足某个条件：

pm.test("Check if property value meets a specific condition", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyValue).to.satisfy(function (value) {
        return value > 0 && value % 2 === 0; // 满足大于0且为偶数的条件
    });
});

验证响应体中的属性是否存在：确保响应体中包含指定的属性。

pm.test("Check if a property exists in the response", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property("propertyName");
});

验证响应体中的属性是否为布尔值：确保响应体中的属性是布尔类型。

pm.test("Check if a property is a boolean in the response", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.booleanProperty).to.be.a("boolean");
});

验证响应体中的属性是否为字符串并且不为空：确保响应体中的属性是非空字符串。

pm.test("Check if a property is a non-empty string in the response", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.stringProperty).to.be.a("string").and.to.not.be.empty;
});

验证响应体中的属性是否为数组并且长度大于零：确保响应体中的属性是数组且长度大于零。

pm.test("Check if a property is an array with length greater than zero", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.arrayProperty).to.be.an("array").and.to.have.length.above(0);
});

验证响应体中的属性是否为对象并且包含指定键：确保响应体中的属性是对象并且包含指定的键。

pm.test("Check if a property is an object with a specific key", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.objectProperty).to.be.an("object").and.to.have.property("specificKey");
});

验证响应体中的属性是否为数字并且大于某个值：

pm.test("Check if a property is a number greater than a specific value", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.numberProperty).to.be.a("number").and.to.be.greaterThan(10);
});

验证响应体中的属性是否满足自定义函数定义的条件：自定义函数用于验证响应体中的属性是否满足特定条件。

// 自定义函数，用于验证属性是否为正偶数
function isPositiveEvenNumber(value) {
    return typeof value === "number" && value > 0 && value % 2 === 0;
}

pm.test("Check if a property meets custom condition", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.customProperty).to.satisfy(isPositiveEvenNumber);
});

验证响应体中的属性是否为特定枚举值之一：确保响应体中的属性是特定枚举值之一。

pm.test("Check if a property has one of the specified enum values", function () {
    var jsonData = pm.response.json();
    var enumValues = ["value1", "value2", "value3"];
    pm.expect(jsonData.enumProperty).to.be.oneOf(enumValues);
});

验证响应体中的属性是否为特定字符串的前缀或后缀：确保响应体中的属性是特定字符串的前缀或后缀。

pm.test("Check if a property has a specific prefix or suffix", function () {
    var jsonData = pm.response.json();
    var prefix = "prefix_";
    var suffix = "_suffix";
    pm.expect(jsonData.stringProperty).to.startWith(prefix).and.to.endWith(suffix);
});

验证响应体中的属性是否为特定正则表达式的匹配：确保响应体中的属性匹配指定的正则表达式。

pm.test("Check if a property matches a specific regex pattern", function () {
    var jsonData = pm.response.json();
    var regexPattern = /^[\d]{3}-[\d]{2}-[\d]{4}$/; // 日期格式为 XXX-XX-XXXX
    pm.expect(jsonData.dateProperty).to.match(regexPattern);
});

验证响应体中的属性是否包含某个子字符串：

pm.test("Check if a property contains a specific substring", function () {
    var jsonData = pm.response.json();
    var substring = "expectedSubstring";
    pm.expect(jsonData.stringProperty).to.include(substring);
});

验证响应体中数组元素的属性是否满足条件：确保数组中的每个元素的属性满足特定条件。

pm.test("Check if array elements meet specific conditions", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.arrayProperty).to.satisfy(function (array) {
        return array.every(function (item) {
            return item.property > 0;
        });
    });
});

验证响应体中属性的值是否与其他属性的值相关联：确保响应体中的属性值之间存在关联关系。

pm.test("Check if properties are correlated in the response", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.property1 + jsonData.property2).to.equal(jsonData.property3);
});

在多次迭代中共享变量并进行验证：在多次迭代中共享变量，并在后续迭代中进行验证。

pm.test("Share variables across iterations and perform validation", function () {
    var jsonData = pm.response.json();

    // 将值保存到环境变量中以便在后续迭代中使用
    pm.environment.set("sharedVariable", jsonData.property);

    // 在后续迭代中验证共享变量的值
    if (pm.info.iteration > 1) {
        pm.expect(pm.environment.get("sharedVariable")).to.equal("expectedValue");
    }
});

在请求之间共享变量并进行验证：在请求之间共享变量，并在后续请求中进行验证。

pm.test("Share variables across requests and perform validation", function () {
    var jsonData = pm.response.json();

    // 将值保存到环境变量中以便在后续请求中使用
    pm.environment.set("sharedVariable", jsonData.property);

    // 发送后续请求，使用共享变量
    pm.sendRequest({
        url: 'https://api.example.com/nextRequest',
        method: 'GET',
        header: {
            'Authorization': `Bearer ${pm.environment.get("sharedVariable")}`
        }
        // 其他请求选项...
    }, function (err, response) {
        // 处理响应...
    });
});

使用 pm.expect 的自定义消息进行更清晰的断言：

pm.test("Use custom message for clearer assertion", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.property, "Property should be equal to expected value").to.equal("expectedValue");
});

使用 pm.expect 的 to.be 链式语法进行更复杂的断言：

pm.test("Complex assertions using chained syntax", function () {
    var jsonData = pm.response.json();
    
    pm.expect(jsonData)
        .to.have.property("property1")
        .that.is.an("array")
        .and.to.have.lengthOf.at.least(1)
        .and.to.include("expectedValue");
});

在数组中查找满足条件的元素：

pm.test("Find element in array that meets a condition", function () {
    var jsonData = pm.response.json();
    
    var matchingElement = jsonData.arrayProperty.find(function (item) {
        return item.property === "expectedValue";
    });

    pm.expect(matchingElement).to.exist;
});

使用 pm.iterationData 进行数据驱动测试：使用 pm.iterationData 进行数据驱动测试，通过外部数据文件或数据集合进行迭代测试。

pm.test("Data-driven testing using pm.iterationData", function () {
    var testData = pm.iterationData.get("testData");
    var jsonData = pm.response.json();

    pm.expect(jsonData.property).to.equal(testData.expectedValue);
});

验证响应体中的属性是否为特定类型的对象：确保响应体中的属性是特定类型的对象，并包含指定的键。

pm.test("Check if a property is of a specific object type", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.objectProperty).to.be.an("object").that.has.all.keys("key1", "key2");
});

验证响应体中的属性是否为特定类型的数组：

pm.test("Check if a property is of a specific array type", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.arrayProperty).to.be.an("array").that.includes("expectedValue");
});

验证响应体中的属性是否为 null 或 undefined：确保响应体中的属性为 null 或 undefined。

pm.test("Check if a property is null or undefined", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.nullOrUndefinedProperty).to.be.oneOf([null, undefined]);
});

在请求中使用动态生成的 UUID：在 "Pre-request Script" 中使用 uuid 库生成 UUID，并将其设置为环境变量，然后在请求中使用。
```
// 在 "Pre-request Script" 中生成 UUID 并设置为环境变量
var uuid = require('uuid');
pm.environment.set('dynamicUUID', uuid.v4());
```

在测试脚本中使用动态生成的时间戳：在测试脚本中生成动态的时间戳进行验证

pm.test("Use dynamic timestamp in the test script", function () {
    var dynamicTimestamp = Math.floor(Date.now() / 1000);
    pm.expect(dynamicTimestamp).to.be.above(0);
});

验证响应体中的属性是否包含某个键，并且该键的值满足条件：

pm.test("Check if property contains a key with a value meeting a condition", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyObject).to.have.property("dynamicKey").that.satisfies(function (value) {
        return value > 0;
    });
});

验证响应体中的属性值是否是指定属性的子集：

pm.test("Check if property values are subsets of another property", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertySubset).to.have.all.keys("key1", "key2").and.to.include.all.values("value1", "value2");
});

在测试脚本中使用环境变量进行条件性验证：在测试脚本中使用环境变量进行条件性验证，根据环境变量的值决定是否执行特定的断言。

pm.test("Conditional validation using environment variable", function () {
    var jsonData = pm.response.json();
    var shouldValidate = pm.environment.get("shouldValidate");

    if (shouldValidate === "true") {
        pm.expect(jsonData.property).to.equal("expectedValue");
    } else {
        console.log("Validation skipped based on environment variable.");
    }
});

验证响应体中的属性值是否近似等于某个数值：确保响应体中的属性值近似等于指定的数值，可以设置一个允许的误差范围。

pm.test("Check if property value is approximately equal to a specific number", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyValue).to.be.closeTo(10.5, 0.1); // 允许的误差为0.1
});

验证响应体中的属性值是否满足正则表达式的条件：使用正则表达式验证响应体中的属性值是否满足特定的条件。

pm.test("Check if property value matches a regular expression", function () {
    var jsonData = pm.response.json();
    var regexPattern = /^[A-Za-z]+$/; // 只包含字母的字符串
    pm.expect(jsonData.propertyValue).to.match(regexPattern);
});

验证响应体中的属性值是否在指定的数组范围内：

pm.test("Check if property value is within a specified array range", function () {
    var jsonData = pm.response.json();
    var validValues = ["value1", "value2", "value3"];
    pm.expect(jsonData.propertyValue).to.be.oneOf(validValues);
});

验证响应体中的属性值是否为真值（例如，非空字符串、非零数字等）：

pm.test("Check if property value is a truthy value", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyValue).to.be.truthy;
});

在测试脚本中使用 pm.response.to.have.property 进行断言：

pm.test("Assertion using pm.response.to.have.property", function () {
    pm.response.to.have.property("propertyName").that.is.a("string").and.to.equal("expectedValue");
});

在测试脚本中使用 pm.expect 和自定义函数进行高级验证：例如验证属性是否为两个数字之和。

// 自定义函数，用于验证属性是否为两个数字之和
function isSumOfTwoNumbers(value, number1, number2) {
    return value === number1 + number2;
}

pm.test("Advanced validation using custom function", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.propertyValue).to.satisfy(isSumOfTwoNumbers, 5, 7);
});

在测试脚本中使用 pm.iteration 和环境变量进行动态验证：根据迭代次数动态获取期望值

pm.test("Dynamic validation using pm.iteration and environment variable", function () {
    var jsonData = pm.response.json();
    var expectedValue = pm.environment.get("expectedValue_" + pm.iteration);

    pm.expect(jsonData.propertyValue).to.equal(expectedValue);
});

在测试脚本中使用pm.expect 和 lodash 库进行深度比较：

// 在 "Pre-request Script" 中安装 lodash 库
// npm install lodash

var _ = require('lodash');

pm.test("Deep comparison using pm.expect and lodash", function () {
    var expectedData = {
        key1: "value1",
        key2: {
            key3: "value3"
        }
    };

    var jsonData = pm.response.json();
    pm.expect(jsonData).to.deep.equal(expectedData);
});

在测试脚本中使用 pm.expect 进行 JSON Schema 验证：

// 在 "Pre-request Script" 中安装 Ajv 库
// npm install ajv

var Ajv = require('ajv');
var ajv = new Ajv();

pm.test("JSON Schema validation using pm.expect", function () {
    var jsonData = pm.response.json();
    var schema = {
        type: 'object',
        properties: {
            property1: { type: 'string' },
            property2: { type: 'number' }
        },
        required: ['property1', 'property2'],
        additionalProperties: false
    };

    var validate = ajv.compile(schema);
    var isValid = validate(jsonData);

    pm.expect(isValid, "Response doesn't match the expected JSON Schema").to.be.true;
});

在测试脚本中使用 pm.expect 进行 XML 验证：

// 在 "Pre-request Script" 中安装 xml2js 库
// npm install xml2js

var parseString = require('xml2js').parseString;

pm.test("XML validation using pm.expect", function () {
    var xmlData = pm.response.text();
    var expectedXml = '<root><element>value</element></root>';

    parseString(xmlData, function (err, result) {
        var expectedResult;
        parseString(expectedXml, function (err, result) {
            expectedResult = result;
        });

        pm.expect(result).to.deep.equal(expectedResult);
    });
});

在测试脚本中使用 pm.test 进行响应时间的验证：确保响应时间在指定的范围内。

pm.test("Check if response time is within expected range", function () {
    pm.expect(pm.response.responseTime).to.be.below(1000); // 期望响应时间在1秒以内
});

在测试脚本中使用 pm.environment 进行环境变量的动态验证：

pm.test("Dynamic validation using environment variable", function () {
    var jsonData = pm.response.json();
    var expectedValue = pm.environment.get("expectedValue");

    pm.expect(jsonData.property).to.equal(expectedValue);
});

在测试脚本中使用 pm.expect 进行 OAuth 2.0 验证：确保响应包含必要的 OAuth 2.0 令牌信息。

pm.test("OAuth 2.0 validation using pm.expect", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.access_token).to.exist;
    pm.expect(jsonData.token_type).to.equal("Bearer");
    pm.expect(jsonData.expires_in).to.be.above(0);
});

在测试脚本中使用 pm.expect 验证跨站请求伪造（CSRF）保护：确保实施了跨站请求伪造保护。

pm.test("CSRF protection validation using pm.expect", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.csrfToken).to.exist;
});

在测试脚本中使用 pm.expect 进行 HTTP 响应码验证：确保响应码是 200。

pm.test("Check if HTTP response code is 200 OK", function () {
    pm.response.to.have.status(200);
});

在测试脚本中使用 pm.expect 验证响应体长度：

pm.test("Check if response body length is within expected range", function () {
    pm.expect(pm.response.text().length).to.be.within(10, 1000);
});

在测试脚本中使用 pm.expect 进行 HTML 响应内容验证：确保响应中包含预期的 HTML 元素。

pm.test("Check if HTML response contains expected element", function () {
    var htmlResponse = pm.response.text();
    pm.expect(htmlResponse).to.include('<title>Expected Title</title>');
});

在测试脚本中使用 pm.expect 验证重定向：检查重定向的目标地址。

pm.test("Check if response is a redirect", function () {
    pm.expect(pm.response.to.have.status(302));
    pm.expect(pm.response.to.have.header("Location", "https://new-location.com"));
});

在测试脚本中使用 pm.expect 验证响应体的 JSONPath 表达式：

pm.test("Check if response JSON contains expected value using JSONPath", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.jsonPath("$.data[0].name", "Expected Name");
});

在测试脚本中使用 pm.expect 进行 HMAC 签名验证：

// 在 "Pre-request Script" 中安装 crypto-js 库
// npm install crypto-js

var CryptoJS = require("crypto-js");

pm.test("HMAC signature validation using pm.expect", function () {
    var jsonData = pm.response.json();
    var secretKey = "yourSecretKey";
    var expectedSignature = CryptoJS.HmacSHA256(JSON.stringify(jsonData), secretKey).toString();

    pm.expect(jsonData.signature).to.equal(expectedSignature);
});

在测试脚本中使用 pm.expect 验证响应体中的属性是否是特定日期格式：

pm.test("Check if date property follows a specific format", function () {
    var jsonData = pm.response.json();
    var dateRegex = /^\d{4}-\d{2}-\d{2}$/; // 日期格式为 YYYY-MM-DD
    pm.expect(jsonData.dateProperty).to.match(dateRegex);
});

在测试脚本中使用 pm.expect 进行 GraphQL 响应验证：

pm.test("GraphQL response validation using pm.expect", function () {
    var jsonData = pm.response.json();

    pm.expect(jsonData).to.have.property("data");
    pm.expect(jsonData.data).to.have.property("user");
    pm.expect(jsonData.data.user).to.have.property("name").that.is.a("string").and.to.equal("ExpectedName");
});

在测试脚本中使用 pm.expect 验证响应体中的属性是否包含特定元素：

pm.test("Check if property contains specific elements", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.arrayProperty).to.include.members(["value1", "value2"]);
});

在测试脚本中使用 pm.expect 验证响应头中是否包含特定键值对：

pm.test("Check if response headers contain specific key-value pairs", function () {
    pm.expect(pm.response.headers.get("Content-Type")).to.equal("application/json");
    pm.expect(pm.response.headers.get("Cache-Control")).to.include("max-age=3600");
});

在测试脚本中使用 pm.expect 验证响应体中的属性值是否为布尔类型：

pm.test("Check if property value is a boolean", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.booleanProperty).to.be.a("boolean");
});

在测试脚本中使用 pm.expect 验证响应体中的属性值是否在指定的数字范围内：
```
pm.test("Check if property value is within a specified number range", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.numberProperty).to.be.within(1, 100);
});
```
关于postman的tests脚本，我整理的暂时就只有这么多，后续学到了新的test脚本的话我也会进行更新，如果大家有关于postman tests的其他脚本，欢迎大家补充分享。文章来源地址https://www.toymoban.com/news/detail-816799.html