How to Write Global Functions in Postman

Question

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

Answer 1

You can declare a global function by assigning this function into a collection, environment or global variable as follows:

• Create a collection variable, i.e. global_func
• In the variable value write this code,

(number)=> { return number * number }

to reuse this function elsewhere in your collection

let numberSquared = eval(pm.variables.get('global_func'))(5)

now, numberSqaure variables has a value of 25

================================

if you need to declare a function library: you can create a collection variable and assign it this piece of code:

({
    print:function() {
        console.log('hello Postman')
    },
    squared:function(number) {
        return number * number
    }
})

Note: the functions have been enclosed with parentheses

to reuse this library:

let lib = eval(pm.variables.get('global_func'))
lib1.print()
console.log(lib1.squared(4))

Good luck :)

Answer 2

Define functions as a global variables then access across all of your tests.

pm.environment.set("UTILS", `({ myFunction: (text) => console.log(text) })`)

Call the functions

let utils = eval(pm.environment.get("UTILS"))
utils.myFunction('Test')

Answer 3

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());

Answer 4

The problem had perplexed me for a while until I found the common way mentioned above. However, it still leaves a warning icon for each eval line, which indicates “eval can be harmful” in the postman interface. Recently, I’ve found another way and post it here: Users can create a prototype object with the proper function you want in the pre-request script section, like this:

Object.prototype.sayHello = function(name){
console.log(`Hello! ${name}`);
};

and call that function everywhere after that. It just required a defined object, like this:

let obj = {};
obj.sayHello(‘Griffin’);

Or you don’t even need the declaration of the object but use some built-in objects instead, like lodash (you pretend it has the function :smile: )

_.sayHello(‘Griffin’);

It’s working on my side. I also posted it in postman forum here https://community.postman.com/t/global-functions-via-collection-level-folder/5927/6?u=franksunnn110

Answer 5

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
});

Answer 6

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.