Merge branch 'main' into fix/remove-jsonbigint-from-cli

packages/bruno-cli/src/commands/run.js

@@ -93,8 +93,68 @@ const printRunSummary = (results) => {
   };
 };
 
+const createCollectionFromPath = (collectionPath) => {
+  const environmentsPath = path.join(collectionPath, `environments`);
+  const getFilesInOrder = (collectionPath) => {
+    let collection = {
+      pathname: collectionPath
+    };
+    const traverse = (currentPath) => {
+      const filesInCurrentDir = fs.readdirSync(currentPath);
+
+      if (currentPath.includes('node_modules')) {
+        return;
+      }
+      const currentDirItems = [];
+      for (const file of filesInCurrentDir) {
+        const filePath = path.join(currentPath, file);
+        const stats = fs.lstatSync(filePath);
+        if (
+          stats.isDirectory() &&
+          filePath !== environmentsPath &&
+          !filePath.startsWith('.git') &&
+          !filePath.startsWith('node_modules')
+        ) {
+          let folderItem = { name: file, pathname: filePath, type: 'folder', items: traverse(filePath) }
+          const folderBruFilePath = path.join(filePath, 'folder.bru');
+          const folderBruFileExists = fs.existsSync(folderBruFilePath);
+          if(folderBruFileExists) {
+            const folderBruContent = fs.readFileSync(folderBruFilePath, 'utf8');
+            let folderBruJson = collectionBruToJson(folderBruContent);
+            folderItem.root = folderBruJson;
+          }
+          currentDirItems.push(folderItem);
+        }
+      }
+
+      for (const file of filesInCurrentDir) {
+        if (['collection.bru', 'folder.bru'].includes(file)) {
+          continue;
+        }
+        const filePath = path.join(currentPath, file);
+        const stats = fs.lstatSync(filePath);
+
+        if (!stats.isDirectory() && path.extname(filePath) === '.bru') {
+          const bruContent = fs.readFileSync(filePath, 'utf8');
+          const bruJson = bruToJson(bruContent);
+          currentDirItems.push({
+            name: file,
+            pathname: filePath,
+            ...bruJson
+          });
+        }
+      }
+      return currentDirItems
+    };
+    collection.items = traverse(collectionPath);
+    return collection;
+  };
+  return getFilesInOrder(collectionPath);
+};
+
 const getBruFilesRecursively = (dir, testsOnly) => {
   const environmentsPath = 'environments';
+  const collection = {};
 
   const getFilesInOrder = (dir) => {
     let bruJsons = [];
@@ -211,6 +271,11 @@ const builder = async (yargs) => {
       description:
         'The specified custom CA certificate (--cacert) will be used exclusively and the default truststore is ignored, if this option is specified. Evaluated in combination with "--cacert" only.'
     })
+    .option('disable-cookies', {
+      type: 'boolean',
+      default: false,
+      description: 'Automatically save and sent cookies with requests'
+    })
     .option('env', {
       describe: 'Environment variables',
       type: 'string'
@@ -259,10 +324,30 @@ const builder = async (yargs) => {
       type: 'boolean',
       description: 'Stop execution after a failure of a request, test, or assertion'
     })
+    .option('reporter-skip-all-headers', {
+      type: 'boolean',
+      description: 'Omit headers from the reporter output',
+      default: false
+    })
+    .option('reporter-skip-headers', {
+      type: 'array',
+      description: 'Skip specific headers from the reporter output',
+      default: []
+    })
+    .option('client-cert-config', {
+      type: 'string',
+      description: 'Path to the Client certificate config file used for securing the connection in the request'
+    })
+
     .example('$0 run request.bru', 'Run a request')
     .example('$0 run request.bru --env local', 'Run a request with the environment set to local')
     .example('$0 run folder', 'Run all requests in a folder')
     .example('$0 run folder -r', 'Run all requests in a folder recursively')
+    .example('$0 run --reporter-skip-all-headers', 'Run all requests in a folder recursively with omitted headers from the reporter output')
+    .example(
+      '$0 run --reporter-skip-headers "Authorization"',
+      'Run all requests in a folder recursively with skipped headers from the reporter output'
+    )
     .example(
       '$0 run request.bru --env local --env-var secret=xxx',
       'Run a request with the environment set to local and overwrite the variable secret with value xxx'
@@ -292,7 +377,8 @@ const builder = async (yargs) => {
     .example(
       '$0 run folder --cacert myCustomCA.pem --ignore-truststore',
       'Use a custom CA certificate exclusively when validating the peers of the requests in the specified folder.'
-    );
+    )
+    .example('$0 run --client-cert-config client-cert-config.json', 'Run a request with Client certificate configurations');
 };
 
 const handler = async function (argv) {
@@ -301,6 +387,7 @@ const handler = async function (argv) {
       filename,
       cacert,
       ignoreTruststore,
+      disableCookies,
       env,
       envVar,
       insecure,
@@ -312,7 +399,10 @@ const handler = async function (argv) {
       reporterHtml,
       sandbox,
       testsOnly,
-      bail
+      bail,
+      reporterSkipAllHeaders,
+      reporterSkipHeaders,
+      clientCertConfig
     } = argv;
     const collectionPath = process.cwd();
 
@@ -329,6 +419,47 @@ const handler = async function (argv) {
     const brunoConfigFile = fs.readFileSync(brunoJsonPath, 'utf8');
     const brunoConfig = JSON.parse(brunoConfigFile);
     const collectionRoot = getCollectionRoot(collectionPath);
+    let collection = createCollectionFromPath(collectionPath);
+    collection = {
+      brunoConfig,
+      root: collectionRoot,
+      ...collection
+    }
+
+    if (clientCertConfig) {
+      try {
+        const clientCertConfigExists = await exists(clientCertConfig);
+        if (!clientCertConfigExists) {
+          console.error(chalk.red(`Client Certificate Config file "${clientCertConfig}" does not exist.`));
+          process.exit(constants.EXIT_STATUS.ERROR_FILE_NOT_FOUND);
+        }
+
+        const clientCertConfigFileContent = fs.readFileSync(clientCertConfig, 'utf8');
+        let clientCertConfigJson;
+
+        try {
+          clientCertConfigJson = JSON.parse(clientCertConfigFileContent);
+        } catch (err) {
+          console.error(chalk.red(`Failed to parse Client Certificate Config JSON: ${err.message}`));
+          process.exit(constants.EXIT_STATUS.ERROR_INVALID_JSON);
+        }
+
+        if (clientCertConfigJson?.enabled && Array.isArray(clientCertConfigJson?.certs)) {
+          if (brunoConfig.clientCertificates) {
+            brunoConfig.clientCertificates.certs.push(...clientCertConfigJson.certs);
+          } else {
+            brunoConfig.clientCertificates = { certs: clientCertConfigJson.certs };
+          }
+          console.log(chalk.green(`Client certificates has been added`));
+        } else {
+          console.warn(chalk.yellow(`Client certificate configuration is enabled, but it either contains no valid "certs" array or the added configuration has been set to false`));
+        }
+      } catch (err) {
+        console.error(chalk.red(`Unexpected error: ${err.message}`));
+        process.exit(constants.EXIT_STATUS.ERROR_UNKNOWN);
+      }
+    }
+
 
     if (filename && filename.length) {
       const pathExists = await exists(filename);
@@ -392,6 +523,9 @@ const handler = async function (argv) {
     if (insecure) {
       options['insecure'] = true;
     }
+    if (disableCookies) {
+      options['disableCookies'] = true;
+    }
     if (cacert && cacert.length) {
       if (insecure) {
         console.error(chalk.red(`Ignoring the cacert option since insecure connections are enabled`));
@@ -516,7 +650,8 @@ const handler = async function (argv) {
         processEnvVars,
         brunoConfig,
         collectionRoot,
-        runtime
+        runtime,
+        collection
       );
 
       results.push({
@@ -525,6 +660,35 @@ const handler = async function (argv) {
         suitename: bruFilepath.replace('.bru', '')
       });
 
+      if (reporterSkipAllHeaders) {
+        results.forEach((result) => {
+          result.request.headers = {};
+          result.response.headers = {};
+        });
+      }
+
+      const deleteHeaderIfExists = (headers, header) => {
+        if (headers && headers[header]) {
+          delete headers[header];
+        }
+      };
+
+      if (reporterSkipHeaders?.length) {
+        results.forEach((result) => {
+          if (result.request?.headers) {
+            reporterSkipHeaders.forEach((header) => {
+              deleteHeaderIfExists(result.request.headers, header);
+            });
+          }
+          if (result.response?.headers) {
+            reporterSkipHeaders.forEach((header) => {
+              deleteHeaderIfExists(result.response.headers, header);
+            });
+          }
+        });
+      }
+
+
       // bail if option is set and there is a failure
       if (bail) {
         const requestFailure = result?.error;

packages/bruno-cli/src/runner/interpolate-vars.js

@@ -13,14 +13,17 @@ const getContentType = (headers = {}) => {
   return contentType;
 };
 
-const interpolateVars = (request, envVars = {}, runtimeVariables = {}, processEnvVars = {}) => {
+const interpolateVars = (request, envVariables = {}, runtimeVariables = {}, processEnvVars = {}) => {
+  const collectionVariables = request?.collectionVariables || {};
+  const folderVariables = request?.folderVariables || {};
+  const requestVariables = request?.requestVariables || {};
   // we clone envVars because we don't want to modify the original object
-  envVars = cloneDeep(envVars);
+  envVariables = cloneDeep(envVariables);
 
   // envVars can inturn have values as {{process.env.VAR_NAME}}
   // so we need to interpolate envVars first with processEnvVars
-  forOwn(envVars, (value, key) => {
-    envVars[key] = interpolate(value, {
+  forOwn(envVariables, (value, key) => {
+    envVariables[key] = interpolate(value, {
       process: {
         env: {
           ...processEnvVars
@@ -36,7 +39,10 @@ const interpolateVars = (request, envVars = {}, runtimeVariables = {}, processEn
 
     // runtimeVariables take precedence over envVars
     const combinedVars = {
-      ...envVars,
+      ...collectionVariables,
+      ...envVariables,
+      ...folderVariables,
+      ...requestVariables,
       ...runtimeVariables,
       process: {
         env: {

packages/bruno-cli/src/runner/prepare-request.js

@@ -1,23 +1,223 @@
-const { get, each, filter } = require('lodash');
+const { get, each, filter, find, compact } = require('lodash');
 const fs = require('fs');
+const os = require('os');
 const decomment = require('decomment');
 const crypto = require('node:crypto');
 
-const prepareRequest = (request, collectionRoot) => {
-  const headers = {};
-  let contentTypeDefined = false;
+const mergeHeaders = (collection, request, requestTreePath) => {
+  let headers = new Map();
 
-  // collection headers
-  each(get(collectionRoot, 'request.headers', []), (h) => {
-    if (h.enabled) {
-      headers[h.name] = h.value;
-      if (h.name.toLowerCase() === 'content-type') {
-        contentTypeDefined = true;
-      }
+  let collectionHeaders = get(collection, 'root.request.headers', []);
+  collectionHeaders.forEach((header) => {
+    if (header.enabled) {
+      headers.set(header.name, header.value);
     }
   });
 
-  each(request.headers, (h) => {
+  for (let i of requestTreePath) {
+    if (i.type === 'folder') {
+      let _headers = get(i, 'root.request.headers', []);
+      _headers.forEach((header) => {
+        if (header.enabled) {
+          headers.set(header.name, header.value);
+        }
+      });
+    } else {
+      const _headers = i?.draft ? get(i, 'draft.request.headers', []) : get(i, 'request.headers', []);
+      _headers.forEach((header) => {
+        if (header.enabled) {
+          headers.set(header.name, header.value);
+        }
+      });
+    }
+  }
+
+  request.headers = Array.from(headers, ([name, value]) => ({ name, value, enabled: true }));
+};
+
+const mergeVars = (collection, request, requestTreePath) => {
+  let reqVars = new Map();
+  let collectionRequestVars = get(collection, 'root.request.vars.req', []);
+  let collectionVariables = {};
+  collectionRequestVars.forEach((_var) => {
+    if (_var.enabled) {
+      reqVars.set(_var.name, _var.value);
+      collectionVariables[_var.name] = _var.value;
+    }
+  });
+  let folderVariables = {};
+  let requestVariables = {};
+  for (let i of requestTreePath) {
+    if (i.type === 'folder') {
+      let vars = get(i, 'root.request.vars.req', []);
+      vars.forEach((_var) => {
+        if (_var.enabled) {
+          reqVars.set(_var.name, _var.value);
+          folderVariables[_var.name] = _var.value;
+        }
+      });
+    } else {
+      const vars = i?.draft ? get(i, 'draft.request.vars.req', []) : get(i, 'request.vars.req', []);
+      vars.forEach((_var) => {
+        if (_var.enabled) {
+          reqVars.set(_var.name, _var.value);
+          requestVariables[_var.name] = _var.value;
+        }
+      });
+    }
+  }
+
+  request.collectionVariables = collectionVariables;
+  request.folderVariables = folderVariables;
+  request.requestVariables = requestVariables;
+
+  if(request?.vars) {
+    request.vars.req = Array.from(reqVars, ([name, value]) => ({
+      name,
+      value,
+      enabled: true,
+      type: 'request'
+    }));
+  }
+
+  let resVars = new Map();
+  let collectionResponseVars = get(collection, 'root.request.vars.res', []);
+  collectionResponseVars.forEach((_var) => {
+    if (_var.enabled) {
+      resVars.set(_var.name, _var.value);
+    }
+  });
+  for (let i of requestTreePath) {
+    if (i.type === 'folder') {
+      let vars = get(i, 'root.request.vars.res', []);
+      vars.forEach((_var) => {
+        if (_var.enabled) {
+          resVars.set(_var.name, _var.value);
+        }
+      });
+    } else {
+      const vars = i?.draft ? get(i, 'draft.request.vars.res', []) : get(i, 'request.vars.res', []);
+      vars.forEach((_var) => {
+        if (_var.enabled) {
+          resVars.set(_var.name, _var.value);
+        }
+      });
+    }
+  }
+
+  if(request?.vars) {
+    request.vars.res = Array.from(resVars, ([name, value]) => ({
+      name,
+      value,
+      enabled: true,
+      type: 'response'
+    }));
+  }
+};
+
+const mergeScripts = (collection, request, requestTreePath, scriptFlow) => {
+  let collectionPreReqScript = get(collection, 'root.request.script.req', '');
+  let collectionPostResScript = get(collection, 'root.request.script.res', '');
+  let collectionTests = get(collection, 'root.request.tests', '');
+
+  let combinedPreReqScript = [];
+  let combinedPostResScript = [];
+  let combinedTests = [];
+  for (let i of requestTreePath) {
+    if (i.type === 'folder') {
+      let preReqScript = get(i, 'root.request.script.req', '');
+      if (preReqScript && preReqScript.trim() !== '') {
+        combinedPreReqScript.push(preReqScript);
+      }
+
+      let postResScript = get(i, 'root.request.script.res', '');
+      if (postResScript && postResScript.trim() !== '') {
+        combinedPostResScript.push(postResScript);
+      }
+
+      let tests = get(i, 'root.request.tests', '');
+      if (tests && tests?.trim?.() !== '') {
+        combinedTests.push(tests);
+      }
+    }
+  }
+
+  request.script.req = compact([collectionPreReqScript, ...combinedPreReqScript, request?.script?.req || '']).join(os.EOL);
+
+  if (scriptFlow === 'sequential') {
+    request.script.res = compact([collectionPostResScript, ...combinedPostResScript, request?.script?.res || '']).join(os.EOL);
+  } else {
+    request.script.res = compact([request?.script?.res || '', ...combinedPostResScript.reverse(), collectionPostResScript]).join(os.EOL);
+  }
+
+  if (scriptFlow === 'sequential') {
+    request.tests = compact([collectionTests, ...combinedTests, request?.tests || '']).join(os.EOL);
+  } else {
+    request.tests = compact([request?.tests || '', ...combinedTests.reverse(), collectionTests]).join(os.EOL);
+  }
+};
+
+const findItem = (items = [], pathname) => {
+  return find(items, (i) => i.pathname === pathname);
+};
+
+const findItemInCollection = (collection, pathname) => {
+  let flattenedItems = flattenItems(collection.items);
+
+  return findItem(flattenedItems, pathname);
+};
+
+const findParentItemInCollection = (collection, pathname) => {
+  let flattenedItems = flattenItems(collection.items);
+
+  return find(flattenedItems, (item) => {
+    return item.items && find(item.items, (i) => i.pathname === pathname);
+  });
+};
+
+const flattenItems = (items = []) => {
+  const flattenedItems = [];
+
+  const flatten = (itms, flattened) => {
+    each(itms, (i) => {
+      flattened.push(i);
+
+      if (i.items && i.items.length) {
+        flatten(i.items, flattened);
+      }
+    });
+  };
+
+  flatten(items, flattenedItems);
+
+  return flattenedItems;
+};
+
+const getTreePathFromCollectionToItem = (collection, _item) => {
+  let path = [];
+  let item = findItemInCollection(collection, _item.pathname);
+  while (item) {
+    path.unshift(item);
+    item = findParentItemInCollection(collection, item.pathname);
+  }
+  return path;
+};
+
+const prepareRequest = (item = {}, collection = {}) => {
+  const request = item?.request;
+  const brunoConfig = get(collection, 'brunoConfig', {});
+  const headers = {};
+  let contentTypeDefined = false;
+
+  const scriptFlow = brunoConfig?.scripts?.flow ?? 'sandwich';
+  const requestTreePath = getTreePathFromCollectionToItem(collection, item);
+  if (requestTreePath && requestTreePath.length > 0) {
+    mergeHeaders(collection, request, requestTreePath);
+    mergeScripts(collection, request, requestTreePath, scriptFlow);
+    mergeVars(collection, request, requestTreePath);
+  }
+
+  each(get(request, 'headers', []), (h) => {
     if (h.enabled) {
       headers[h.name] = h.value;
       if (h.name.toLowerCase() === 'content-type') {
@@ -34,7 +234,7 @@ const prepareRequest = (request, collectionRoot) => {
     responseType: 'arraybuffer'
   };
 
-  const collectionAuth = get(collectionRoot, 'request.auth');
+  const collectionAuth = get(collection, 'root.request.auth');
   if (collectionAuth && request.auth.mode === 'inherit') {
     if (collectionAuth.mode === 'basic') {
       axiosRequest.auth = {
@@ -151,10 +351,19 @@ const prepareRequest = (request, collectionRoot) => {
     axiosRequest.data = graphqlQuery;
   }
 
-  if (request.script && request.script.length) {
+  if (request.script) {
     axiosRequest.script = request.script;
   }
 
+  if (request.tests) {
+    axiosRequest.tests = request.tests;
+  }
+
+  axiosRequest.vars = request.vars;
+  axiosRequest.collectionVariables = request.collectionVariables;
+  axiosRequest.folderVariables = request.folderVariables;
+  axiosRequest.requestVariables = request.requestVariables;
+
   return axiosRequest;
 };
 

packages/bruno-cli/src/runner/run-single-request.js

@@ -20,6 +20,7 @@ const { addAwsV4Interceptor, resolveAwsV4Credentials } = require('./awsv4auth-he
 const { shouldUseProxy, PatchedHttpsProxyAgent } = require('../utils/proxy-util');
 const path = require('path');
 const { createFormData, parseDataFromResponse } = require('../utils/common');
+const { getCookieStringForUrl, saveCookies, shouldUseCookies } = require('../utils/cookies');
 const protocolRegex = /^([-+\w]{1,25})(:?\/\/|:)/;
 
 const onConsoleLog = (type, args) => {
@@ -35,13 +36,17 @@ const runSingleRequest = async function (
   processEnvVars,
   brunoConfig,
   collectionRoot,
-  runtime
+  runtime,
+  collection
 ) {
   try {
     let request;
     let nextRequestName;
-
-    request = prepareRequest(bruJson.request, collectionRoot);
+    let item = { 
+      pathname: path.join(collectionPath, filename),
+      ...bruJson
+    }
+    request = prepareRequest(item, collection);
 
     request.__bruno__executionMode = 'cli';
 
@@ -49,10 +54,7 @@ const runSingleRequest = async function (
     scriptingConfig.runtime = runtime;
 
     // run pre request script
-    const requestScriptFile = compact([
-      get(collectionRoot, 'request.script.req'),
-      get(bruJson, 'request.script.req')
-    ]).join(os.EOL);
+    const requestScriptFile = get(request, 'script.req');
     if (requestScriptFile?.length) {
       const scriptRuntime = new ScriptRuntime({ runtime: scriptingConfig?.runtime });
       const result = await scriptRuntime.runRequestScript(
@@ -178,6 +180,14 @@ const runSingleRequest = async function (
       });
     }
 
+    //set cookies if enabled
+    if (!options.disableCookies) {
+      const cookieString = getCookieStringForUrl(request.url);
+      if (cookieString && typeof cookieString === 'string' && cookieString.length) {
+        request.headers['cookie'] = cookieString;
+      }
+    }
+
     // stringify the request url encoded params
     if (request.headers['content-type'] === 'application/x-www-form-urlencoded') {
       request.data = qs.stringify(request.data);
@@ -223,6 +233,11 @@ const runSingleRequest = async function (
       // Prevents the duration on leaking to the actual result
       responseTime = response.headers.get('request-duration');
       response.headers.delete('request-duration');
+
+      //save cookies if enabled
+      if (!options.disableCookies) {
+        saveCookies(request.url, response.headers);
+      }
     } catch (err) {
       if (err?.response) {
         const { data } = parseDataFromResponse(err?.response);
@@ -251,7 +266,7 @@ const runSingleRequest = async function (
             data: null,
             responseTime: 0
           },
-          error: err.message,
+          error: err?.message || err?.errors?.map(e => e?.message)?.at(0) || err?.code || 'Request Failed!',
           assertionResults: [],
           testResults: [],
           nextRequestName: nextRequestName
@@ -282,10 +297,7 @@ const runSingleRequest = async function (
     }
 
     // run post response script
-    const responseScriptFile = compact([
-      get(collectionRoot, 'request.script.res'),
-      get(bruJson, 'request.script.res')
-    ]).join(os.EOL);
+    const responseScriptFile = get(request, 'script.res');
     if (responseScriptFile?.length) {
       const scriptRuntime = new ScriptRuntime({ runtime: scriptingConfig?.runtime });
       const result = await scriptRuntime.runResponseScript(
@@ -330,7 +342,7 @@ const runSingleRequest = async function (
 
     // run tests
     let testResults = [];
-    const testFile = compact([get(collectionRoot, 'request.tests'), get(bruJson, 'request.tests')]).join(os.EOL);
+    const testFile = get(request, 'tests');
     if (typeof testFile === 'string') {
       const testRuntime = new TestRuntime({ runtime: scriptingConfig?.runtime });
       const result = await testRuntime.runTests(

packages/bruno-cli/src/utils/bru.js

@@ -58,7 +58,7 @@ const bruToJson = (bru) => {
         body: _.get(json, 'body', {}),
         vars: _.get(json, 'vars', []),
         assertions: _.get(json, 'assertions', []),
-        script: _.get(json, 'script', ''),
+        script: _.get(json, 'script', {}),
         tests: _.get(json, 'tests', '')
       }
     };

packages/bruno-cli/src/utils/cookies.js

@@ -0,0 +1,100 @@
+const { Cookie, CookieJar } = require('tough-cookie');
+const each = require('lodash/each');
+
+const cookieJar = new CookieJar();
+
+const addCookieToJar = (setCookieHeader, requestUrl) => {
+  const cookie = Cookie.parse(setCookieHeader, { loose: true });
+  cookieJar.setCookieSync(cookie, requestUrl, {
+    ignoreError: true // silently ignore things like parse errors and invalid domains
+  });
+};
+
+const getCookiesForUrl = (url) => {
+  return cookieJar.getCookiesSync(url);
+};
+
+const getCookieStringForUrl = (url) => {
+  const cookies = getCookiesForUrl(url);
+
+  if (!Array.isArray(cookies) || !cookies.length) {
+    return '';
+  }
+
+  const validCookies = cookies.filter((cookie) => !cookie.expires || cookie.expires > Date.now());
+
+  return validCookies.map((cookie) => cookie.cookieString()).join('; ');
+};
+
+const getDomainsWithCookies = () => {
+  return new Promise((resolve, reject) => {
+    const domainCookieMap = {};
+
+    cookieJar.store.getAllCookies((err, cookies) => {
+      if (err) {
+        return reject(err);
+      }
+
+      cookies.forEach((cookie) => {
+        if (!domainCookieMap[cookie.domain]) {
+          domainCookieMap[cookie.domain] = [cookie];
+        } else {
+          domainCookieMap[cookie.domain].push(cookie);
+        }
+      });
+
+      const domains = Object.keys(domainCookieMap);
+      const domainsWithCookies = [];
+
+      each(domains, (domain) => {
+        const cookies = domainCookieMap[domain];
+        const validCookies = cookies.filter((cookie) => !cookie.expires || cookie.expires > Date.now());
+
+        if (validCookies.length) {
+          domainsWithCookies.push({
+            domain,
+            cookies: validCookies,
+            cookieString: validCookies.map((cookie) => cookie.cookieString()).join('; ')
+          });
+        }
+      });
+
+      resolve(domainsWithCookies);
+    });
+  });
+};
+
+const deleteCookiesForDomain = (domain) => {
+  return new Promise((resolve, reject) => {
+    cookieJar.store.removeCookies(domain, null, (err) => {
+      if (err) {
+        return reject(err);
+      }
+
+      return resolve();
+    });
+  });
+};
+
+const saveCookies = (url, headers) => {
+  let setCookieHeaders = [];
+  if (headers['set-cookie']) {
+    setCookieHeaders = Array.isArray(headers['set-cookie'])
+      ? headers['set-cookie']
+      : [headers['set-cookie']];
+    for (let setCookieHeader of setCookieHeaders) {
+      if (typeof setCookieHeader === 'string' && setCookieHeader.length) {
+        addCookieToJar(setCookieHeader, url);
+      }
+    }
+  }
+}
+
+module.exports = {
+  addCookieToJar,
+  getCookiesForUrl,
+  getCookieStringForUrl,
+  getDomainsWithCookies,
+  deleteCookiesForDomain,
+  saveCookies
+};