probe.gl/dist/es5/test-utils/browser-automation/browser-test-driver.js

JavaScript Console Instrumentation and Benchmarking for Browser and Node

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _browserDriver = _interopRequireDefault(require("./browser-driver"));

var _color = require("../../lib/utils/color");

var _diffImages = _interopRequireDefault(require("../image-utils/diff-images"));

var MAX_CONSOLE_MESSAGE_LENGTH = 500;

var BrowserTestDriver = function (_BrowserDriver) {
  (0, _inherits2.default)(BrowserTestDriver, _BrowserDriver);

  function BrowserTestDriver() {
    (0, _classCallCheck2.default)(this, BrowserTestDriver);
    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(BrowserTestDriver).apply(this, arguments));
  }

  (0, _createClass2.default)(BrowserTestDriver, [{
    key: "run",
    value: function run() {
      var _this = this;

      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var _config$title = config.title,
          title = _config$title === void 0 ? 'Browser Test' : _config$title,
          _config$headless = config.headless,
          headless = _config$headless === void 0 ? false : _config$headless;
      this.title = title;
      this.headless = headless;
      this.time = Date.now();
      this.failures = 0;
      this.logger.log({
        message: "".concat(title),
        color: _color.COLOR.BRIGHT_YELLOW
      })();
      return this._startServer(config.server || config).then(function (url) {
        return _this._openPage(url, config);
      }).then(function (result) {
        return _this._onFinish(result);
      }).catch(function (error) {
        _this._fail(error.message || error);
      });
    }
  }, {
    key: "_openPage",
    value: function _openPage(url) {
      var _this2 = this;

      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var browserConfig = Object.assign({}, config.browser, {
        headless: this.headless
      });
      return this.startBrowser(browserConfig).then(function (_) {
        return new Promise(function (resolve, reject) {
          var exposeFunctions = Object.assign({}, config.exposeFunctions, {
            browserTestDriver_fail: function browserTestDriver_fail() {
              return _this2.failures++;
            },
            browserTestDriver_finish: function browserTestDriver_finish(message) {
              return resolve(message);
            },
            browserTestDriver_captureAndDiffScreen: function browserTestDriver_captureAndDiffScreen(opts) {
              return _this2._captureAndDiff(opts);
            },
            onerror: reject
          });

          if (config.exposeFunction) {
            _this2.logger.removed('exposeFunction', 'browserTestDriver_sendMessage');
          }

          _this2.logger.log({
            message: 'Loading page in browser...',
            color: _color.COLOR.BRIGHT_YELLOW
          })();

          _this2.openPage({
            url: config.url || url,
            exposeFunctions: exposeFunctions,
            onConsole: function onConsole(event) {
              return _this2._onConsole(event);
            },
            onError: reject
          });
        });
      });
    }
  }, {
    key: "_startServer",
    value: function _startServer() {
      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      if (!config) {
        return null;
      }

      if (typeof config === 'function') {
        return config();
      }

      return this.startServer(config);
    }
  }, {
    key: "_onConsole",
    value: function _onConsole(event) {
      if (!this.headless) {
        return;
      }

      var text = event.text().slice(0, MAX_CONSOLE_MESSAGE_LENGTH);

      switch (event.type()) {
        case 'log':
          console.log(text);
          break;

        case 'warning':
          console.log((0, _color.addColor)(text, _color.COLOR.YELLOW));
          break;

        case 'error':
          console.log((0, _color.addColor)(text, _color.COLOR.RED));
          break;

        default:
      }
    }
  }, {
    key: "_onFinish",
    value: function _onFinish(message) {
      var elapsed = ((Date.now() - this.time) / 1000).toFixed(1);
      this.logger.log({
        message: "".concat(this.title, " completed in ").concat(elapsed, "s."),
        color: _color.COLOR.BRIGHT_YELLOW
      })();

      if (this.failures) {
        this._fail(message || "".concat(this.failures, " test").concat(this.failures > 1 ? 's' : '', " failed"));
      } else {
        this._pass(message || 'All tests passed');
      }
    }
  }, {
    key: "_pass",
    value: function _pass(message) {
      this.logger.log({
        message: "".concat(this.title, " successful: ").concat(message),
        color: _color.COLOR.BRIGHT_GREEN
      })();

      if (this.headless) {
        this.exit(0);
      }
    }
  }, {
    key: "_fail",
    value: function _fail(message) {
      this.logger.log({
        message: "".concat(this.title, " failed: ").concat(message),
        color: _color.COLOR.BRIGHT_RED
      })();

      if (this.headless) {
        this.exit(1);
      }
    }
  }, {
    key: "_captureAndDiff",
    value: function _captureAndDiff(opts) {
      if (!opts.goldenImage) {
        return Promise.reject(new Error('Must supply golden image for image diff'));
      }

      var screenshotOptions = {
        type: 'png',
        omitBackground: true,
        encoding: 'binary'
      };

      if (opts.region) {
        screenshotOptions.clip = opts.region;
      } else {
        screenshotOptions.fullPage = true;
      }

      return this.page.screenshot(screenshotOptions).then(function (image) {
        return (0, _diffImages.default)(image, opts.goldenImage, opts);
      }).catch(function (error) {
        return {
          success: false,
          match: 0,
          error: error.message
        };
      });
    }
  }]);
  return BrowserTestDriver;
}(_browserDriver.default);

exports.default = BrowserTestDriver;
//# sourceMappingURL=browser-test-driver.js.map