I was pretty unsatisfied with the functionality regarding loading libraries into Postman. I really disliked having to go into my environment file, copy the code out, paste it into another editor, then add it back to the environment. So, I came up with a solution! LOAD!
Now, this DOES require a necessary evil. The following LOAD function needs to be stored in your globals, at least once.
(arg I canāt figure out how to format code hereā¦)
Script = require(āpostman-collectionā).Script;
function LOAD(library) {
const pullLibrary = {
url: 'https://api.getpostman.com/collections/' + pm.environment.get(collection),
method: 'GET',
header: {
'X-Api-Key': environment.postmanApiKey
}
};
let x;
if (library == 'all') {
pm.sendRequest(pullLibrary, function(err, res) {
for(x in res.json().collection.item[0].item){
script = new Script(res.json().collection.item[0].item[x].event[0].script);
pm.environment.set('' + res.json().collection.item[0].item[x].name, script.toSource());
console.log('loaded ' + res.json().collection.item[0].item[x].name);
}
});
} else {
pm.sendRequest(pullLibrary, function(err, res) {
let foundLibrary = (_.findWhere(res.json().collection.item[0].item, {
name: library
}));
if(foundLibrary){
script = new Script(foundLibrary.event[0].script);
pm.environment.set('' + foundLibrary.name, script.toSource());
console.log('loaded ' + foundLibrary.name);
} else {
throw new Error('library ' + library + ' does not exist!');
}
});
};
};
First, you need to save the LOAD script into your globals,
Then, create a new collection in your workspace called āLibrariesā
Add a new environment variable named collection, and set it to use the āLibraryā collectionās uuid provided by the Postman API, e.g. 1234123-abc12345-aaaa-bbbb-cccc-123456789123
Create a subfolder called āScriptsā
This is where you would create new requests. Put any code you want to reuse in the āTestsā tab. You can add as many requests as you like, each containing their own special code.
Create another environment variable, postmanApiKey, which will contain your postman api key.
Run eval(globals.LOAD) in any pre-request, then LOAD(āallā)
After that, you can call any script saved this way just by using eval(environment.yourRequestScriptsName).
While this is still using the old, typical solution of cluttering up the environment file, it allows you to edit your scripts in an actual editor, without having to copy and paste them in and out of the environment. LOAD only really needs to be run once at the beginning of a run, just to pick up any changes made to your library.
If anyone has any questions, tips, or improvements, please let me know! Iām still new to javascript and have a lot to learn.
If I understand correctly, is the main aim here to ease sharing of common snippets between workspaces since global/environment variable scope is limited to a workspace?
Itās a clever approach to use the Postman API to fetch resources from one part of Postman for use in another!
Along the same lines as this, I put together a pre-request script and local server that allows you to pull in external modules not included in the sandbox:
Iām going to review your snippet a little more to see if thereās improvements I can make to the way Iām executing my script, and, perhaps you might like to flick through mine for the same.
I really like your approach, your code is much neater than mine. I really dig the approach using the global variable require, makes it much more intuitive to use, itās very clever! I think I might implement some of your methods, specifically using require and storing all packages in one variable.
I should probably go through mine again anyways and see if thereās a way to neaten it up or download all at once (as opposed to a bunch of requests). Just realized it is missing the Postman Scripts require at the top, somehow the post deleted it, will fix that in my op. Might be a way to use that to process the scripts without using eval, actually.
Only thing I can really think of is maybe adding an update check to the local server when pkgs returns installed, but Iām not really sure how important checking for updates would be.
I updated @akaczinski code (a huge thanks to him toiling around for a rather elegant hack to this problem) to accept an array and be a bit clearer and concise as well as have better names and to use the global scope for variables rather than environment. I also used a convention I started where I adopted this script to reference variables not in Requests or JSON and that live strictly within Postman with an _. Here is the modified code and modified steps below:
function _includeLibrary(library) {
let Script = require('postman-collection').Script
const postmanApiRequest = {
url: 'https://api.getpostman.com/collections/' + pm.globals.get('_includeLibrariesCollectionUuid'),
method: 'GET',
header: {
'X-Api-Key': pm.globals.get('_postmanApiKey')
}
}
pm.sendRequest(postmanApiRequest, function (err, res) {
if (_.isArray(library)) {
_.forEach(library, function (libraryName) {
if (libraryName == 'all') {
throw new Error('_includeLibrary: The library "all" cannot be in an array of libraries to include.')
}
const foundLibrary = (_.findWhere(res.json().collection.item[0].item, {
name: libraryName
}))
if (foundLibrary) {
script = new Script(foundLibrary.event[0].script)
pm.globals.set('' + foundLibrary.name, script.toSource())
console.log('_includeLibrary: Loaded the "' + foundLibrary.name + '" library.')
} else {
throw new Error('_includeLibrary: The library "' + libraryName + '" does not exist.')
}
})
} else if (_.isString(library)) {
switch (library) {
case '':
case '*':
case 'all':
for (const x in res.json().collection.item[0].item) {
script = new Script(res.json().collection.item[0].item[x].event[0].script)
pm.globals.set('' + res.json().collection.item[0].item[x].name, script.toSource())
console.log('_includeLibrary: Library "' + res.json().collection.item[0].item[x].name + '" loaded.')
}
break
default:
_includeLibrary([library])
break
}
} else {
_includeLibrary('*')
}
})
}
First, you need to save the script into a variable named _includeLibrary into your Global variables
Create a new collection in your workspace named ā_includedLibrariesā
Add a new Global variable named _includeLibrariesCollectionUuid and set it to use the _includeLibrariesCollection collectionās UUID provided by the Postman API (e.g. 1234123-abc12345-aaaa-bbbb-cccc-123456789123)
Create a folder in the _includeLibrariesCollection called āscriptsā
This is where you would create new Requests. Put ALL code you want to reuse in the āTestsā tab and there is no need to fill out anything else. You can add as many Requests as you like, each containing their own special code.
Create another Global variable, _postmanApiKey, which will contain your Postman API key.
Run eval(pm.globals.get(ā_includeLibrariesFunctionā)) and then _includeLibrary([āfooā, ābarā, āexternal-minified-jsā]) in any Pre-Request Test. Optionally you can specify: _includeLibrary(ā*ā) to include ALL of the scripts you have saved.
After that, you can call any script saved this way just by using eval(pm.globals.get(āfooā)) and then subsequently calling any functions defined in those scripts with this.myHelloWorldFunction() (note the this).
EDIT: The text formatting tool for whatever Postman is using for these community boards is AWFUL!