How to Write Global Functions in Postman

I need help writing a common function to use across a collection of requests which will help with building a framework.

I have tried using the below format

The following function is declared in the Test tab in the first function

postman.setGlobalVariable("function", function function1(parameters)
{
  //sample code
});

I used the following in the pre-request

var delay = eval(globals.function);
delay.function1(value1);

I am getting the following error

there was error while evaluating the Pre-request script : Cannot read property 'function1' of undefined.

Can anyone help me with how to define Global/common functions and use them across the requests?

Thanks in advance

Solution 1:

Without eval:

Define an object containing your function(s) in the collection's pre-request scripts without using let, var, etc. This attaches it to Postman's global sandbox object.

utils = {
  myFunc: function() {
    return 'hello';
  }
};

Then within your request's pre-request or test script section just call the function:

console.log(utils.myFunc());

Solution 2:

I use this little hack:

pm.globals.set('loadUtils', function loadUtils() {
    let utils = {};
    utils.reuseableFunction = function reuseableFunction() {
        let jsonData = JSON.parse(responseBody);
    }
    return utils;
} + '; loadUtils();');
tests['Utils initialized'] = true;

In another request I can reuse the global variable loadUtils:

const utils = eval(globals.loadUtils);
utils.reuseableFunction();

You can also check the developer roadmap of the Postman team. Collection-level scripts are on the near-term agenda and should be available soon until then you can use the shown method.

Solution 3:

Edit: The following answer is still valid and you can skip ahead and read it, but I want to give a warning first: If you are trying use this in Postman, you should probably use something else than Postman, like Mocha, for your testing. Postman is OK for small to medium scale applications but very large multi-developers applications can be a nightmare to maintain with postman. The in-app editor is a mess for large files, and versioning can be problematic.

ANSWER
You can have a more readable solution and more possibility to factor your code (like calling function1() from function2() directly inside your pre-request script, or declaring packages) with the following syntax :

Initialize environment (or globals) :

postman.setEnvironmentVariable("utils", () => {
    var myFunction1 = () => {
        //do something
    }
    var myFunction2 = () => {
        let func1Result = myFunction1();
        //do something else
    }
    return {
        myPackage: {
            myFunction1,
            myFunction2
        }
    };
});

And then use your functions in a later test :

let utils = eval(environment.utils)();
utils.myPackage.myFunction1(); //calls myFunction1()
utils.myPackage.myFunction2(); //calls myFunction2() which uses myFunction1()

Bonus :

If you are calling an API and need to wait the call to finish before performing a test, you can do something like this:

postman.setEnvironmentVariable("utils", () => {
    var myFunction = (callback) => {
        return pm.sendRequest({
            // call your API with postman here
        }, function (err, res) {
            if (callback) {
                //if a callback method has been given, it's called
                callback();
            }
        });
    }
    
    return {
        myPackage: {
            myFunction,
        }
    };
});

and then to use it:

utils.myPackage.myFunction(function() {
    console.log("this is the callback !")
    //perform test here
});

Solution 4:

If you want to call pm.sendRequest in a global function, try this:

1. Define the global function in collection pre-request, like this:

   pm.globals.set('globalFunction', parameters => {
       console.log(parameters);
       pm.sendRequest('https://google.com/', function(err, resp) {
           pm.expect(err).to.not.be.ok;
       });
   });
   

2. Use function like this:

   eval(globals.globalFunction)('hello world!!');

Note that, I declared function using arrow style ()=>{}. Otherwise, it wouldn't work.