How to Store Runtime Variables from Scripts for Token Handling Across Entire Collection?

[mpsoares]

Hi everyone,

I’m working on a script to handle authentication tokens, but I’ve run into an issue where the variables I set are only available per request, not across the entire collection. I need these variables, like the token and its expiry, to persist throughout multiple requests within the collection.

Here’s the script I’m using to fetch and reuse the authentication token:

const axios = require('axios');

// Initialize environment variables
const server = bru.getEnvVar('keycloakUrl');
const realm = bru.getEnvVar('KeycloakRealm');
const grantType = 'password';
const clientId = bru.getEnvVar('clientId');
const clientSecret = bru.getEnvVar('clientSecret');
const username = bru.getEnvVar('Username');
const password = bru.getEnvVar('Password');
const tenantId = bru.getEnvVar('tenantId');

// Construct the request URL and body
const requestUrl = '${server}/auth/realms/${realm}/protocol/openid-connect/token';
const requestBody = 'grant_type=${grantType}&client_id=${clientId}&username=${username}&password=${password}&client_secret=${clientSecret}';

// Check if token and expiry date are available and valid
const tokenExpiry = bru.getEnvVar('accessTokenExpiry');
const accessToken = bru.getEnvVar('ktoken');

let getToken = false;

// Check if the token is expired or missing
if (!tokenExpiry || !accessToken) {
    console.log('Token or expiry date are missing');
    getToken = true;
} else if (Number(tokenExpiry) <= (new Date()).getTime()) {
    console.log('Token is expired');
    getToken = true;
} else {
    console.log('Using existing token');
    bru.setEnvVar('authorizationHeader', 'Bearer ${accessToken}');  // Save to env var
}

// Define headers for token request
let headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'tenantid': tenantId
};

// Fetch a new token if needed
if (getToken) {
    axios.post(requestUrl, requestBody, {
        headers,
        httpsAgent: new (require('https').Agent)({
            rejectUnauthorized: false // Disable SSL verification
        })
    }).then(response => {
        const responseJson = response.data;
        const token = responseJson.access_token;
        
        // Set the token as an environment variable
        bru.setEnvVar('ktoken', token);
        bru.setEnvVar('authorizationHeader', 'Bearer ${token}');  // Save token as a header env var
        
        // Calculate the token's expiry date and set it
        const expiryDate = new Date();
        expiryDate.setSeconds(expiryDate.getSeconds() + responseJson.expires_in - 60); // Deduct 60 seconds for safety
        bru.setEnvVar('accessTokenExpiry', expiryDate.getTime());

        console.log('Token fetched and set successfully');
    }).catch(error => {
        // Improved error handling
        if (error.response) {
            // Server responded with a status other than 200 range
            console.error('Error response from server:', error.response.data);
            console.error('Status code:', error.response.status);
            console.error('Headers:', error.response.headers);
        } else if (error.request) {
            // No response was received
            console.error('No response received:', error.request);
        } else {
            // Something else happened while setting up the request
            console.error('Error while setting up request:', error.message);
        }
    });
} else {
    console.log('Using existing token');
}

The problem is, even though I store the token and expiry date in environment variables, they don’t seem to persist across other requests in the same collection. Is there a way to make these variables available across all requests in a collection during runtime?

Any guidance or suggestions would be really appreciated!

Thanks a lot!

[mpsoares]

The solution was to change SetEnvVar to SerVar. Also, axios should be called async. Here's a modified script that works:

`const axios = require('axios');
const moment = require('moment');

const calculateTokenExpiry = (tokenExpiryVarName) => {
const currentTime = moment()
const expiryTime = moment(bru.getVar(tokenExpiryVarName)) || currentTime
bru.setVar('CurrentTime',moment().format());
return expiryTime.diff(currentTime, 'milliseconds')
}

const authenticateClient = async (config) => {
const {
TokenEndpointVarName,
ClientIdVarName,
ClientSecretVarName,
BearerTokenVarName,
UsernameVarName,
PasswordVarName,
RealmVarName
} = config

//console.log('Checking for required variables...')
if (!BearerTokenVarName) {
throw new Error('Missing environment variable for storing bearer token');
}
//console.log('Calculating token expiry...')
const expiryDifference = calculateTokenExpiry(expiryFor_${BearerTokenVarName})

const oneMinute = 60000

if (expiryDifference >= oneMinute && bru.getVar('lastRequestEnvName') === bru.getEnvName()){
return
}

const envVariables = {
  [TokenEndpointVarName]: bru.getEnvVar(TokenEndpointVarName),
  [ClientIdVarName]: bru.getEnvVar(ClientIdVarName),
  [ClientSecretVarName]: bru.getEnvVar(ClientSecretVarName),
  [UsernameVarName]: bru.getEnvVar(UsernameVarName),
  [PasswordVarName]: bru.getEnvVar(PasswordVarName),
  [RealmVarName]: bru.getEnvVar(RealmVarName)
}

//console.log('Checking for missing variables...')
const missingVariables = Object.entries(envVariables).filter(([key, value]) => !value).map(([key]) => key)

if (missingVariables.length > 0) {
  throw new Error(`Missing required variables: ${missingVariables.join(', ')}`)
}

try {
//console.log('Authenticating...')
const requestUrl = ${envVariables[TokenEndpointVarName]}/auth/realms/${envVariables[RealmVarName]}/protocol/openid-connect/token;
const requestBody = {
grant_type: 'password',
client_id: envVariables[ClientIdVarName],
client_secret: envVariables[ClientSecretVarName],
username: envVariables[UsernameVarName],
password: envVariables[PasswordVarName]
}
console.log(requestUrl)
console.log(requestBody)

const httpsAgent = new (require('https').Agent)({
  rejectUnauthorized: false // Ignore SSL certificate verification
});

const tokenData = (await axios.post(requestUrl, requestBody, {
  headers: {'Content-Type': 'application/x-www-form-urlencoded'},
  httpsAgent: httpsAgent
})).data;

const token = tokenData.access_token;
bru.setVar(BearerTokenVarName, tokenData.access_token);
bru.setVar(`expiryFor_${BearerTokenVarName}`, moment().add(tokenData.expires_in, 'seconds').format());
bru.setVar('lastRequestEnvName', bru.getEnvName());

} catch (error) {
throw new Error(Failed to authenticate: ${error.message});
}

}

await authenticateClient({
TokenEndpointVarName: 'keycloakUrl',
ClientIdVarName: 'clientId',
ClientSecretVarName: 'clientSecret',
UsernameVarName: 'username',
PasswordVarName: 'password',
BearerTokenVarName: 'bearerToken',
RealmVarName: 'realm'
})

`

Thanks to https://www.youtube.com/watch?v=zEWmi6UHj_g