Added TestandWait for CLI & Script

Author: Siddhantshukla814

README.md

@@ -63,6 +63,7 @@ $ webpagetest --help
 - **locations** _[options]_: list locations and the number of pending tests
 - **testers** _[options]_: list testers status and details
 - **test** _[options] \<url_or_script\>_: run test, _\<url_or_script\>_ can also be a path to a script file
+- **testAndWait** _[options] \<url_or_script\>_: run test and waits for the result, _\<url_or_script\>_ can also be a path to a script file
 - **testBalance** _[options]_: get remaining tests for the account
 - **restart** _\<id\>_: restart test
 - **cancel** _\<id\>_: cancel running/pending test
@@ -448,6 +449,7 @@ Methods and options (including the one letter shorthands) are the same when usin
 - `getTesters(options, callback)`
 - `getTestBalance(options, callback)`
 - `runTest(url_or_script, options, callback)`
+- `runTestAndWait(url_or_script, options, callback)`
 - `restartTest(id, options, callback)`
 - `cancelTest(id, options, callback)`
 - `getHARData(id, options, callback)`
@@ -516,7 +518,7 @@ wpt.runTest(script, (err, data) => {
 - **dryRun**: _Boolean_, if `true`, method does not make an actual request to the API Server but rather returns an object with `url` which contains the actual URL to make the GET request to WebPageTest API Server
 - **server**: _String_, if specified, overrides the WebPageTest server informed in the constructor only for that method call
 
-#### Test (works for `runTest` method only)
+#### Test (works with `runTest` and `runTestAndWait`)
 
 - **location**: _String_, location to test from
 - **connectivity**: _String_, connectivity profile -- requires location to be specified -- (Cable|DSL|3GSlow|3G|3GFast|4G|LTE|Edge|2G|Dial|FIOS|Native|custom) [Cable]
@@ -590,15 +592,15 @@ wpt.runTest(script, (err, data) => {
 - **lighthouse**: _Boolean_, perform lighthouse test (Chrome only, Linux agent only)
 - **throttleCPU**: _Number_, custom cpu throttling
 
-#### API Key (works for `runTest`, `restartTest` and `cancelTest` methods)
+#### API Key (works for `runTest`, `runTestAndWait`, `restartTest` and `cancelTest` methods)
 
 - **key**: _String_, API key (if assigned). Contact the WebPageTest server administrator for a key if required
 
-#### Request (works for `getTestStatus` `getResults` `getLocations` `getTesters` and `runTest` methods)
+#### Request (works for `getTestStatus` `getResults` `getLocations` `getTesters` `runTest` and `runTestAndWait` methods)
 
 - **requestId**: _String_, echo request ID, useful to track asynchronous requests
 
-#### Results (works for `getResults` and `runTest` methods)
+#### Results (works for `getResults` `runTest` and `runTestAndWait` methods)
 
 - **breakDown**: _Boolean_, include the breakdown of requests and bytes by mime type
 - **domains**: _Boolean_, include the breakdown of requests and bytes by domain

lib/mapping.js

@@ -814,6 +814,13 @@ var commands = {
     info: "run test",
     nokey: [options.results],
   },
+  testAndWait: {
+    name: "runTestAndWait",
+    param: "url_or_script",
+    options: [options.apikey, options.test, options.request, options.results],
+    info: "run test and waits for the result",
+    nokey: [options.results],
+  },
   restart: {
     name: "restartTest",
     param: "id",

lib/webpagetest.js

@@ -530,6 +530,202 @@ function runTest(what, options, callback) {
   return api.call(this, paths.test, callback, query, options);
 }
 
+function runTestAndWait(what, options, callback) {
+  delete options.pollResults;
+  delete options.timeout;
+  options = Object.assign(options, { pollResults: 10 });
+
+  var query = {};
+
+  callback = callback || options;
+  options = options === callback ? {} : helper.deepClone(options);
+
+  // testing url or script?
+  query[reSpace.test(what) ? "script" : "url"] = what;
+  // set dummy url when scripting, needed when webdriver script
+  if (query.script) {
+    query.url = "https://www.webpagetest.org";
+  }
+  helper.setQuery(mapping.commands.test, options, query);
+
+  // connectivity
+  if (reConnectivity.test(options.connectivity) && query.location) {
+    query.location += "." + options.connectivity;
+  }
+
+  // json output format
+  query.f = "json";
+
+  // API key
+  if (!query.k && this.config.key) {
+    query.k = this.config.key;
+  }
+
+  // synchronous tests with results
+  var testId,
+    polling,
+    server,
+    listen,
+    timerout,
+    resultsOptions = {};
+
+  function resultsCallback(err, data) {
+    clearTimeout(timerout);
+    if (options.exitOnResults) {
+      process.exit(err);
+    } else {
+      callback(err, data);
+    }
+  }
+
+  function poll(err, data) {
+    // poll again when test started but not complete
+    // and not when specs are done testing
+    if (
+      !err &&
+      (!data || (data && data.data && data.statusCode !== 200)) &&
+      !(typeof err === "number" && data === undefined)
+    ) {
+      console.log(
+        data && data.data && data.data.statusText
+          ? data.data.statusText
+          : "Testing in progress"
+      );
+      polling = setTimeout(
+        getTestResults.bind(this, testId, resultsOptions, poll.bind(this)),
+        options.pollResults
+      );
+    } else {
+      if (!data) {
+        data = { testId: testId };
+      }
+      resultsCallback(err, data);
+    }
+  }
+
+  function testCallback(cb, err, data) {
+    if (err || !(data && data.data && data.data.testId)) {
+      return callback(err || data);
+    }
+
+    testId = data.data.testId;
+
+    if (options.timeout) {
+      timerout = setTimeout(timeout, options.timeout);
+    }
+
+    if (cb) {
+      cb.call(this);
+    }
+  }
+
+  function timeout() {
+    if (server) {
+      server.close();
+    }
+    clearTimeout(polling);
+    callback({
+      error: {
+        code: "TIMEOUT",
+        testId: testId,
+        message: "timeout",
+      },
+    });
+  }
+
+  function listener() {
+    query.pingback = url.format({
+      protocol: "http",
+      hostname: options.waitResults.hostname,
+      port: options.waitResults.port,
+      pathname: "/testdone",
+    });
+
+    api.call(this, paths.test, testCallback.bind(this, null), query, options);
+  }
+
+  function wait() {
+    server.listen(options.waitResults.port, listen);
+    return options.waitResults;
+  }
+
+  // poll|wait results timeout
+  if (options.timeout) {
+    options.timeout = (parseInt(options.timeout, 10) || 0) * 1000;
+  }
+
+  // poll|wait results options
+  Object.keys(mapping.options.results).forEach(function resultsOpts(key) {
+    var name = mapping.options.results[key].name,
+      value = options[name] || options[key];
+
+    if (value !== undefined) {
+      resultsOptions[name] = value;
+    }
+  });
+
+  // poll results
+  if (options.pollResults && !options.dryRun) {
+    options.pollResults = parseInt(options.pollResults * 1000, 10) || 5000;
+
+    return api.call(
+      this,
+      paths.test,
+      testCallback.bind(this, poll),
+      query,
+      options
+    );
+  }
+
+  // wait results
+  if (options.waitResults && !options.dryRun) {
+    options.waitResults = helper.localhost(
+      options.waitResults,
+      WebPageTest.defaultWaitResultsPort
+    );
+
+    listen = listener.bind(this);
+
+    server = http.createServer(
+      function (req, res) {
+        var uri = url.parse(req.url, true);
+
+        res.statusCode = 204;
+        res.end();
+
+        if (uri.pathname === "/testdone" && uri.query.id === testId) {
+          server.close(
+            getTestResults.bind(
+              this,
+              uri.query.id,
+              resultsOptions,
+              resultsCallback
+            )
+          );
+        }
+      }.bind(this)
+    );
+
+    server.on(
+      "error",
+      function (err) {
+        if (["EACCES", "EADDRINUSE"].indexOf(err.code) > -1) {
+          // remove old unused listener and bump port for next attempt
+          server.removeListener("listening", listen);
+          options.waitResults.port++;
+          wait.call(this);
+        } else {
+          callback(err);
+        }
+      }.bind(this)
+    );
+
+    return wait.call(this);
+  }
+
+  return api.call(this, paths.test, callback, query, options);
+}
+
 function restartTest(id, options, callback) {
   var query = { resubmit: id };
 
@@ -932,6 +1128,7 @@ WebPageTest.prototype = {
   getLocations: getLocations,
   getTesters: getTesters,
   runTest: runTest,
+  runTestAndWait: runTestAndWait,
   restartTest: restartTest,
   cancelTest: cancelTest,
   getPageSpeedData: getPageSpeedData,