Postman 邮递员/纽曼在失败时重试

在Newman中，我希望测试以确保响应代码正确，响应时间合理，响应值正确

在某些情况下，由于网络故障或其他一些系统条件，某些请求可能会以超时或错误值结束，如果几秒钟后处理相同的请求，这些值将得到解决

在这种情况下，我希望在请求之间用Y超时重试相同的请求x次

---

如果重试后迭代通过，我希望Newman退出代码为0（成功运行）。

您可以设置如下请求工作流：

const code = (responseCode.code === 200);

if (code === 200 && environment.counter < X) {
    // Stop execution
    tests["Status code is 200"] = code;
    postman.setNextRequest();
}
else {
    // retry the same request
    postman.setNextRequest("Name of this request");
}

使用请求创建集合，然后：

在预请求选项卡中，您可以实现计数器：

// Counter for number of requests
var counter = environment.counter ? _.parseInt(environment.counter) + 1 : 1;
postman.setEnvironmentVariable("counter", counter);

您的测试选项卡如下所示：

const code = (responseCode.code === 200);

if (code === 200 && environment.counter < X) {
    // Stop execution
    tests["Status code is 200"] = code;
    postman.setNextRequest();
}
else {
    // retry the same request
    postman.setNextRequest("Name of this request");
}

---

几个小时后，我完成了这样一个功能：

function retryOnFailure(successCode, numberOfRetrys) {
    var key = request.name + '_counter';
    var execCounter = postman.getEnvironmentVariable(key) || 1;

    var sleepDuration = 1000;
    var waitUntilTime = new Date().getTime() + sleepDuration;
    if (responseCode.code !== successCode && execCounter <= numberOfRetrys) {
        while (new Date().getTime() < waitUntilTime) {
            // Do Nothing -> Wait
        }
        console.log('Retrying: ' + request.name + '\nGot: ' + responseCode.code + ' Expected: ' + successCode + '\nWaited: ' + sleepDuration / 1000 + 'sec  \nRetry Number: ' + execCounter + ' of ' + numberOfRetrys);
        execCounter++;
        postman.setEnvironmentVariable(key, execCounter);
        postman.setNextRequest(request.name);
    }
}

---

下面是针对同一问题的可重用函数

postmanFunctions.common.retryOnFailure(predicate,retryCount,waitbetweenRetrySec,ReroutetorequestifNeeded ,postmanAssertions);

• 谓词函数决定成败
• 断言函数具有所有postman断言
• 如果“重新路由”为空，则在重试尝试后执行断言
• 具有retrycount和waittime的灵活轮询（如果谓词不再传递 轮询/回流）
• 有一个maxflow计数器（env var），它将流跳数限制为 避免无限循环

将以下函数存储在全局或环境中：

() => {
var sleep = (sleepDuration) => {
    var startTime = new Date().getTime();
    while (new Date().getTime() - startTime < sleepDuration) {}
}
var sleepByAsyncDelayTime = () => {
    var sleepDuration = postman.getEnvironmentVariable('asyncDelayTime') || 0;
    sleep(sleepDuration);
}
var retryOnFailure = (predicate, numberOfRetrys, sleepDuration, reRouteRequestName, postmanAssertions) => {
    var retryCountPerReq_key = request.name + '_retry_count';
    var retryCountPerReq = pm.environment.get(retryCountPerReq_key) || 0;
    var reflowCountPerReq_key = request.name + '_reflow_count';
    var reflowCountPerReq = pm.environment.get(reflowCountPerReq_key) || 0;
    var totalReflowCount_key = 'totalReflowCount';
    var totalReflowCount = pm.environment.get(totalReflowCount_key) || 0;
    var maxReflowCounter = postman.getEnvironmentVariable('maxReflowCounter') || 0;
    var maxReflowCounterPerReq = postman.getEnvironmentVariable('maxReflowCounterPerReq') || 0;

    function clearAndExit() {
        pm.environment.unset(retryCountPerReq_key);
        pm.environment.unset(reflowCountPerReq_key);
        postmanAssertions();
    }

    function retry() {
        sleep(sleepDuration);
        pm.environment.set(retryCountPerReq_key, ++retryCountPerReq);
        postman.setNextRequest(request.name);
    }

    function reFlow() {
        if (totalReflowCount < maxReflowCounter && reflowCountPerReq < maxReflowCounterPerReq) {
            pm.environment.unset(retryCountPerReq_key);
            pm.environment.set(totalReflowCount_key, ++totalReflowCount);
            pm.environment.set(reflowCountPerReq_key, ++reflowCountPerReq);
            postman.setNextRequest(reRouteRequestName);
        } else clearAndExit();
    }
    if (predicate()) clearAndExit();
    else if (retryCountPerReq < numberOfRetrys) retry();
    else if (reRouteRequestName != '') reFlow();
    else clearAndExit();
}
return {
    common: {
        sleepByAsyncDelayTime,
        sleep,
        retryOnFailure
    }
};

（）=>{
变量睡眠=（睡眠持续时间）=>{
var startTime=new Date（）.getTime（）；
while（new Date（）.getTime（）-startTime{
var sleepDuration=postman.getEnvironmentVariable（'asyncDelayTime'）| | 0；
睡眠（睡眠持续时间）；
}
var retryOnFailure=（谓词、numberOfRetrys、sleepDuration、reRouteRequestName、postmanasertions）=>{
var retryCountPerReq_key=request.name+“_retry_count”；
var retryCountPerReq=pm.environment.get（retryCountPerReq_键）| 0；
var reflowCountPerReq_key=request.name+'u reflow_count'；
var reflowCountPerReq=pm.environment.get（reflowCountPerReq_键）| 0；
var totalReflowCount_key='totalReflowCount'；
var totalReflowCount=pm.environment.get（totalReflowCount_键）| 0；
var maxReflowCounter=postman.getEnvironmentVariable（'maxReflowCounter'）|| 0；
var maxReflowCounterPerReq=postman.getEnvironmentVariable（'maxReflowCounterPerReq'）| | 0；
函数clearAndExit（）{
pm.environment.unset（retryCountPerReq_键）；
pm.environment.unset（reflowCountPerReq_键）；
邮递服务（）；
}
函数重试（）{
睡眠（睡眠持续时间）；
pm.environment.set（retryCountPerReq_键，++retryCountPerReq）；
postman.setNextRequest（request.name）；
}
函数回流（）{
if（totalReflowCount

---

}

是的，可重用函数可能是更好的解决方案。与邮递员/纽曼一起获得一些优雅的重试逻辑是一项艰巨的工作。我希望尽快实现可重用的全局脚本。我们将把这个脚本放在哪里，它放在我们的postman集合的

测试脚本

部分？您可以通过pm.globals.set（）将它放在postman环境变量中，并在每次需要该函数时对其执行eval（）

() => {
var sleep = (sleepDuration) => {
    var startTime = new Date().getTime();
    while (new Date().getTime() - startTime < sleepDuration) {}
}
var sleepByAsyncDelayTime = () => {
    var sleepDuration = postman.getEnvironmentVariable('asyncDelayTime') || 0;
    sleep(sleepDuration);
}
var retryOnFailure = (predicate, numberOfRetrys, sleepDuration, reRouteRequestName, postmanAssertions) => {
    var retryCountPerReq_key = request.name + '_retry_count';
    var retryCountPerReq = pm.environment.get(retryCountPerReq_key) || 0;
    var reflowCountPerReq_key = request.name + '_reflow_count';
    var reflowCountPerReq = pm.environment.get(reflowCountPerReq_key) || 0;
    var totalReflowCount_key = 'totalReflowCount';
    var totalReflowCount = pm.environment.get(totalReflowCount_key) || 0;
    var maxReflowCounter = postman.getEnvironmentVariable('maxReflowCounter') || 0;
    var maxReflowCounterPerReq = postman.getEnvironmentVariable('maxReflowCounterPerReq') || 0;

    function clearAndExit() {
        pm.environment.unset(retryCountPerReq_key);
        pm.environment.unset(reflowCountPerReq_key);
        postmanAssertions();
    }

    function retry() {
        sleep(sleepDuration);
        pm.environment.set(retryCountPerReq_key, ++retryCountPerReq);
        postman.setNextRequest(request.name);
    }

    function reFlow() {
        if (totalReflowCount < maxReflowCounter && reflowCountPerReq < maxReflowCounterPerReq) {
            pm.environment.unset(retryCountPerReq_key);
            pm.environment.set(totalReflowCount_key, ++totalReflowCount);
            pm.environment.set(reflowCountPerReq_key, ++reflowCountPerReq);
            postman.setNextRequest(reRouteRequestName);
        } else clearAndExit();
    }
    if (predicate()) clearAndExit();
    else if (retryCountPerReq < numberOfRetrys) retry();
    else if (reRouteRequestName != '') reFlow();
    else clearAndExit();
}
return {
    common: {
        sleepByAsyncDelayTime,
        sleep,
        retryOnFailure
    }
};