add code for generate-downloads command

Author: Karan Nagpal

bin/commands/generateDownloads.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const logger = require("../helpers/logger").winstonLogger,
+      Constants = require("../helpers/constants"),
+      utils = require("../helpers/utils"),
+      downloadBuildArtifacts = require('../helpers/buildArtifacts').downloadBuildArtifacts;
+
+
+module.exports = async function generateDownloads(args) {
+  let bsConfigPath = utils.getConfigPath(args.cf);
+
+  return utils.validateBstackJson(bsConfigPath).then(async function (bsConfig) {
+    // setting setDefaults to {} if not present and set via env variables or via args.
+    utils.setDefaults(bsConfig, args);
+
+    // accept the username from command line if provided
+    utils.setUsername(bsConfig, args);
+
+    // accept the access key from command line if provided
+    utils.setAccessKey(bsConfig, args);
+
+    utils.setUsageReportingFlag(bsConfig, args.disableUsageReporting);
+
+    // set cypress config filename
+    utils.setCypressConfigFilename(bsConfig, args);
+
+    let messageType = Constants.messageTypes.INFO;
+    let errorCode = null;
+    let buildId = args._[1];
+
+    await downloadBuildArtifacts(bsConfig, buildId, args);
+    utils.sendUsageReport(bsConfig, args, 'generate-downloads called', messageType, errorCode);
+  }).catch(function (err) {
+    logger.error(err);
+    utils.setUsageReportingFlag(null, args.disableUsageReporting);
+    utils.sendUsageReport(null, args, err.message, Constants.messageTypes.ERROR, utils.getErrorCodeFromErr(err));
+  });
+};

bin/commands/runs.js

@@ -141,11 +141,13 @@ module.exports = function run(args) {
                   utils.handleSyncExit(exitCode, data.dashboard_url);
                 });
               });
+            } else {
+              logger.info(Constants.userMessages.ASYNC_DOWNLOADS.replace('<build-id>', data.build_id));
             }
 
             logger.info(message);
             logger.info(dashboardLink);
-            if(!args.sync) logger.info(Constants.userMessages.EXIT_SYNC_CLI_MESSAGE.replace("<build-id>",data.build_id));
+            if(!args.sync) logger.info(Constants.userMessages.EXIT_SYNC_CLI_MESSAGE.replace("<build-id>", data.build_id));
             let dataToSend = {
               time_components: getTimeComponents(),
               build_id: data.build_id,

bin/helpers/buildArtifacts.js

@@ -14,65 +14,79 @@ const logger = require('./logger').winstonLogger,
 
 
 const parseAndDownloadArtifacts = async (buildId, data) => {
-  return new Promise((resolve, reject) => {
+  return new Promise(async (resolve, reject) => {
     let all_promises = [];
     let combs = Object.keys(data);
     for(let i = 0; i < combs.length; i++) {
       let comb = combs[i];
       let sessions = Object.keys(data[comb]);
       for(let j = 0; j < sessions.length; j++) {
         let sessionId = sessions[j];
-        let filePath = path.join('./', 'buildArtifacts', buildId, comb, sessionId);
-        let fileName = 'buildArtifacts.zip';
-        console.log(`adding promise for sessionID=${sessionId}`);
+        let filePath = path.join('./', 'build_artifacts', buildId, comb, sessionId);
+        let fileName = 'build_artifacts.zip';
         process.env.BUILD_ARTIFACTS_TOTAL_COUNT = Number(process.env.BUILD_ARTIFACTS_TOTAL_COUNT) + 1
         all_promises.push(downloadAndUnzip(filePath, fileName, data[comb][sessionId]).catch((error) => {
           process.env.BUILD_ARTIFACTS_FAIL_COUNT = Number(process.env.BUILD_ARTIFACTS_FAIL_COUNT) + 1;
-          reject;
+          reject(error);
         }));
       }
     }
-    Promise.all(all_promises)
-      .then(() => {
-        resolve;
-      })
+    await Promise.all(all_promises);
+    resolve();
+  });
+}
+
+const createDirIfNotPresent = async (dir) => {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(dir)){
+      fs.mkdirSync(dir);
+    }
+    resolve();
   });
 }
 
 const createDirectories = async (buildId, data) => {
-  // create dir for buildArtifacts if not already present
-  let artifactsDir = path.join('./', 'buildArtifacts');
+  // create dir for build_artifacts if not already present
+  let artifactsDir = path.join('./', 'build_artifacts');
   if (!fs.existsSync(artifactsDir)){
     fs.mkdirSync(artifactsDir);
   }
 
   // create dir for buildId if not already present
-  let buildDir = path.join('./', 'buildArtifacts', buildId);
+  let buildDir = path.join('./', 'build_artifacts', buildId);
   if (fs.existsSync(buildDir)){
     // remove dir in case already exists
     fs.rmdirSync(buildDir, { recursive: true, force: true });
   }
   fs.mkdirSync(buildDir);
 
-  // create subdirs for combinations inside build
-  Object.keys(data).forEach(comb => {
-    let combDir = path.join('./', 'buildArtifacts', buildId, comb);
-    if (!fs.existsSync(combDir)){
-      fs.mkdirSync(combDir);
+  let combDirs = [];
+  let sessionDirs = [];
+  let combs = Object.keys(data);
+
+  for(let i = 0; i < combs.length; i++) {
+    let comb = combs[i];
+    let combDir = path.join('./', 'build_artifacts', buildId, comb);
+    combDirs.push(createDirIfNotPresent(combDir));
+    let sessions = Object.keys(data[comb]);
+    for(let j = 0; j < sessions.length; j++) {
+      let sessionId = sessions[j];
+      let sessionDir = path.join('./', 'build_artifacts', buildId, comb, sessionId);
+      sessionDirs.push(createDirIfNotPresent(sessionDir));
     }
+  }
 
-    // create subdirs for each parellel consumed for each combination
-    Object.keys(data[comb]).forEach(sessionId => {
-      let sessionDir = path.join('./', 'buildArtifacts', buildId, comb, sessionId);
-      if (!fs.existsSync(sessionDir)){
-        fs.mkdirSync(sessionDir);
-      }
-    })
+  return new Promise(async (resolve) => {
+    // create sub dirs for each combination in build
+    await Promise.all(combDirs);
+    // create sub dirs for each machine id in combination
+    await Promise.all(sessionDirs);
+    resolve();
   });
 }
 
 const downloadAndUnzip = async (filePath, fileName, url) => {
-  return new Promise((resolve, reject) => {
+  return new Promise(async (resolve, reject) => {
     let tmpFilePath = path.join(filePath, fileName);
     https.get(url, function(response) {
       response.on('data', function (data) {
@@ -82,15 +96,16 @@ const downloadAndUnzip = async (filePath, fileName, url) => {
         fs.createReadStream(tmpFilePath).pipe(unzipper.Extract({ path: filePath })
           .on('close', function () {
             fs.unlinkSync(tmpFilePath);
-            resolve;
+            resolve();
           })
           .on('error', function(err) {
-            reject;
+            process.env.BUILD_ARTIFACTS_FAIL_COUNT = Number(process.env.BUILD_ARTIFACTS_FAIL_COUNT) + 1;
+            reject(err);
           })
         );
       });
       response.on('error', function () {
-        reject;
+        reject();
       })
     });
   });
@@ -143,28 +158,32 @@ exports.downloadBuildArtifacts = async (bsConfig, buildId, args) => {
   let message = null;
   let messageType = null;
   let errorCode = null;
-  let build;
 
   try {
       const res = await axios.get(url, options);
       let buildDetails = res.data;
 
       await createDirectories(buildId, buildDetails);
       await parseAndDownloadArtifacts(buildId, buildDetails);
-      await sendUpdatesToBstack(bsConfig, buildId, args, options);
 
-      messageType = Constants.messageTypes.SUCCESS;
-      message = `Build artifacts for build: ${buildId} were successfully downloaded.`;
-      logger.info(message);
-  } catch (err) {
-    //TODO: handle error codes - 422 etc
+      if (process.env.BUILD_ARTIFACTS_FAIL_COUNT > 0) {
+        messageType = Constants.messageTypes.ERROR;
+        message = Constants.userMessages.DOWNLOAD_BUILD_ARTIFACTS_FAILED.replace('<build-id>', buildId).replace('<machine-count>', process.env.BUILD_ARTIFACTS_FAIL_COUNT);
+        logger.error(message);
+      } else {
+        messageType = Constants.messageTypes.SUCCESS;
+        message = Constants.userMessages.DOWNLOAD_BUILD_ARTIFACTS_SUCCESS.replace('<build-id>', buildId).replace('<user-path>', process.cwd());
+        logger.info(message);
+      }
 
-    message = err;
+      await sendUpdatesToBstack(bsConfig, buildId, args, options);
+      utils.sendUsageReport(bsConfig, args, message, messageType, null);
+  } catch (err) {
     messageType = Constants.messageTypes.ERROR;
     errorCode = 'api_failed_build_artifacts';
 
     logger.error('Downloading the build artifacts failed.');
-    logger.error(message);
-    utils.sendUsageReport(bsConfig, args, message, messageType, errorCode);
+    logger.error(err);
+    utils.sendUsageReport(bsConfig, args, err, messageType, errorCode);
   }
 };

bin/helpers/constants.js

@@ -43,7 +43,9 @@ const userMessages = {
   LOCAL_STOP_FAILED: "Local Binary stop failed.",
   INVALID_LOCAL_MODE_WARNING: "Invalid value specified for local_mode. local_mode: (\"always-on\" | \"on-demand\"). For more info, check out https://www.browserstack.com/docs/automate/cypress/cli-reference",
   SPEC_LIMIT_WARNING: "You might not see all your results on the dashboard because of high spec count, please consider reducing the number of spec files in this folder.",
-  DOWNLOAD_BUILD_ARTIFACTS: "Downloading build artifacts for the build <build-id> failed."
+  DOWNLOAD_BUILD_ARTIFACTS_FAILED: "Downloading build artifacts for the build <build-id> failed for <machine-count> machines.",
+  ASYNC_DOWNLOADS: "Test artifacts as specified under 'downloads' can be downloaded after the build has completed its run, using 'browserstack-cypress generate-downloads <build-id>'",
+  DOWNLOAD_BUILD_ARTIFACTS_SUCCESS: "Your build artifact(s) have been successfully downloaded in '<user-path>/build_artifacts/<build-id>' directory"
 };
 
 const validationMessages = {
@@ -84,17 +86,13 @@ const cliMessages = {
     INFO: "Check status of your build.",
     STOP: "Stop your build.",
     DEMAND: "Requires a build id.",
-    DESC: "Path to BrowserStack config",
-    CONFIG_DEMAND: "config file is required",
     INFO_MESSAGE: "Getting information for buildId ",
     STOP_MESSAGE: "Stopping build with given buildId ",
   },
   RUN: {
     PARALLEL_DESC: "The maximum number of parallels to use to run your test suite",
     INFO: "Run your tests on BrowserStack.",
-    DESC: "Path to BrowserStack config",
     CYPRESS_DESC: "Path to Cypress config file",
-    CONFIG_DEMAND: "config file is required",
     CYPRESS_CONFIG_DEMAND: "Cypress config file is required",
     BUILD_NAME: "The build name you want to use to name your test runs",
     EXCLUDE: "Exclude files matching a pattern from zipping and uploading",
@@ -117,10 +115,15 @@ const cliMessages = {
     USERNAME: "Your BrowserStack username",
     ACCESS_KEY: "Your BrowserStack access key",
     NO_NPM_WARNING: "No NPM warning if npm_dependencies is empty",
+    CONFIG_DEMAND: "config file is required",
+    CONFIG_FILE_PATH: "Path to BrowserStack config",
   },
   GENERATE_REPORT: {
     INFO: "Generates the build report"
   },
+  GENERATE_DOWNLOADS: {
+    INFO: "Downloads the build artifacts"
+  },
 };
 
 const messageTypes = {

bin/helpers/utils.js

@@ -736,11 +736,11 @@ exports.setCypressConfigs = (bsConfig, args) => {
 
 exports.getCypressJSON = (bsConfig) => {
   if (
-    bsConfig.runSettings.cypress_config_file &&
-    bsConfig.runSettings.cypress_config_filename !== 'false'
+    bsConfig.run_settings.cypress_config_file &&
+    bsConfig.run_settings.cypress_config_filename !== 'false'
   ) {
     let cypressJSON = JSON.parse(
-      fs.readFileSync(bsConfig.runSettings.cypressConfigFilePath)
+      fs.readFileSync(bsConfig.run_settings.cypressConfigFilePath)
     );
     return cypressJSON;
   }