docs: function(instance, callback) {
          var ERR_CODE_NAME_MAP   = {},
              TestStatusEnum      = Client.TestStatusEnum,
              IndicatorsEnum      = Client.IndicatorsEnum,
              StreamStatusEnum    = JetStream.StatusEnum,
              result              = TestStatusEnum.PASS,
              self                = this,
              tests               = this.tests.concat(),
              getTestURL          = this.getTestURL.bind(this),
              config              = this.config,
              client              = config.client,
              //existingTunnel    = TunnelClient.usingExistingProcess(this.tunnel);
              username            = client.username,
              key                 = client.key,
              timeout             = client.timeout,
              instanceOS          = capitalize(instance.os),
              instanceBrowser     = capitalize(instance.browser),
              instanceVersion     = instance['browser-version'],
              port                = client.port || config.port || 4000,
              server              = url.format({ protocol: config.secure && 'https' || 'http', host: client.domain + ':' + port }),
              hostname            = os.hostname(),
              name                = this.name;
  
          ERR_CODE_NAME_MAP[StreamStatusEnum.CLIENT_ERROR]      = 'CLIENT_ERROR';
          ERR_CODE_NAME_MAP[StreamStatusEnum.CONNECTION_ERROR]  = 'CONNECTION_ERROR';
          ERR_CODE_NAME_MAP[StreamStatusEnum.SERVICE_ERROR]     = 'SERVICE_ERROR';
  
          function run(test) {
              var EPOCH       = '&_=' + Number(new Date),
                  jetstream   = null,
                  job         = [hostname, instanceOS, instanceBrowser + ' ' + instanceVersion, Client.getTestPathFromURL(test)].join(' - '),
                  parsed      = url.parse(test),             
                  browser     = soda.createSauceClient({
                                  'url': server,
                                  'username': username,
                                  'access-key': key,
                                  'max-duration': timeout,
                                  'browser': instanceBrowser,
                                  'browser-version': instanceVersion,
                                  'os': instanceOS
                              });
  
              Logger.log('JetRunner client (' + name + ') - testing remote job "' + job + '"...');
              Logger.log('JetRunner URL: '.grey + decodeURIComponent(test + EPOCH).cyan);
  
              browser
                  .chain
                  .session()
                  .setContext('sauce:job-name=' + job)
                  //.setContext('tunnel-identifier:' + (!existingTunnel && TUNNEL_ID || ''))
                  .open(parsed.pathname + parsed.search + EPOCH)
                  .waitForPageToLoad(client.timeout)
                  .getEval('window.jetstream', function(stream) { jetstream = new JetStream(stream); })
                  .end(function(err) {
                      var data = jetstream.data,
                          status = err && TestStatusEnum.FAIL || data.status,
                          failed = !!(err || status || data.payload.results.failures),
                          errors = data.errors;
  
                      this.setContext('sauce:job-info={"passed": ' + !failed + '}', function() {
                          browser.testComplete(function() {
                              Logger.log('JetRunner client (' + name + ') - finished remote job "' + job +'": ' + (failed && IndicatorsEnum.FAILURE || IndicatorsEnum.SUCCESS));
                              Logger.log('SauceLabs job URL: '.grey + browser.jobUrl.cyan);
                              Logger.log('SauceLabs video URL: '.grey + browser.videoUrl.cyan);
                              Logger.log('SauceLabs log URL: '.grey + browser.logUrl.cyan);
  
                              if(err) {
                                  Logger.log('JetRunner client (' + name + ') - error: ' + err);
                              } else if(data.status !== StreamStatusEnum.OK) {
                                  Logger.log(('\nJetStream.' + ERR_CODE_NAME_MAP[data.status] + ':').yellow);
                                  Logger.log(('* ' + substitute(errors.join('\n* '), { port: port })).yellow);
                              } else {
                                  self._reporter.addSuite(data.payload.suite, job);
                              }
  
                              if(config.debug) {
                                  Logger.log(('\njetstream ' + jetstream).grey);
                              }
  
                              next(failed);
                          });
                      });
                  });
          }
  
          function next(failed) {
              result |= failed;
              if((!failed || client.continueOnFail) && tests.length) {
                  run(getTestURL(tests.shift()));
              } else {
                  callback && callback(result);
              }
          }
  
          next();
      }