@percy/core 1.0.0-beta.8 → 1.0.1

package/test/helpers/server.js

@@ -0,0 +1,33 @@
+// aliased to src for coverage during tests without needing to compile this file
+import Server from '../../dist/server.js';
+
+export function createTestServer({ default: defaultReply, ...replies }, port = 8000) {
+  let server = new Server();
+
+  // alternate route handling
+  let handleReply = reply => async (req, res) => {
+    let [status, headers, body] = typeof reply === 'function' ? await reply(req) : reply;
+    if (!Buffer.isBuffer(body) && typeof body !== 'string') body = JSON.stringify(body);
+    return res.send(status, headers, body);
+  };
+
+  // map replies to alternate route handlers
+  server.reply = (p, reply) => (replies[p] = handleReply(reply), null);
+  for (let [p, reply] of Object.entries(replies)) server.reply(p, reply);
+  if (defaultReply) defaultReply = handleReply(defaultReply);
+
+  // track requests and route replies
+  server.requests = [];
+  server.route(async (req, res, next) => {
+    let pathname = req.url.pathname;
+    if (req.url.search) pathname += req.url.search;
+    server.requests.push(req.body ? [pathname, req.body] : [pathname]);
+    let reply = replies[req.url.pathname] || defaultReply;
+    return reply ? await reply(req, res) : next();
+  });
+
+  // automatically listen
+  return server.listen(port);
+};
+
+export default createTestServer;

package/types/index.d.ts

@@ -1,71 +1,101 @@
-// Minimum TypeScript Version: 3.8
-import Puppeteer from 'puppeteer-core';
+// utility types
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
 
 type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'silent';
-interface Pojo { [x: string]: any; }
 
-export interface SnapshotOptions {
-  widths?: number[];
-  minHeight?: number;
-  percyCSS?: string;
-  requestHeaders?: Pojo;
-  enableJavaScript?: boolean;
+interface Pojo {
+  [x: string]: any;
+}
+
+interface AuthCredentials {
+  username: string;
+  password: string;
 }
 
 interface DiscoveryOptions {
+  requestHeaders?: Pojo;
+  authorization?: AuthCredentials;
   allowedHostnames?: string[];
+  disableCache?: boolean;
+}
+
+interface DiscoveryLaunchOptions {
+  executable?: string;
+  args?: string[];
+  timeout?: number;
+  headless?: boolean;
+}
+
+interface AllDiscoveryOptions extends DiscoveryOptions {
   networkIdleTimeout?: number;
-  disableAssetCache?: boolean;
   concurrency?: number;
-  launchOptions?: Pojo;
+  launchOptions?: DiscoveryLaunchOptions;
 }
 
-export type PercyOptions<C = Pojo> = C & {
-  token?: string,
+interface CommonSnapshotOptions {
+  widths?: number[];
+  minHeight?: number;
+  percyCSS?: string;
+  enableJavaScript?: boolean;
+}
+
+export interface SnapshotOptions extends CommonSnapshotOptions {
+  discovery?: DiscoveryOptions;
+}
+
+type ClientEnvInfo = {
   clientInfo?: string,
-  environmentInfo?: string,
+  environmentInfo?: string
+}
+
+export type PercyConfigOptions<C = Pojo> = C & {
+  snapshot?: CommonSnapshotOptions,
+  discovery?: AllDiscoveryOptions
+}
+
+export type PercyOptions<C = Pojo> = {
+  token?: string,
   server?: boolean,
   port?: number,
   concurrency?: number,
   loglevel?: LogLevel,
-  config?: undefined | string | false,
-  snapshot?: SnapshotOptions,
-  discovery?: DiscoveryOptions
-};
+  config?: undefined | string | false
+} & ClientEnvInfo & PercyConfigOptions<C>;
+
+type SnapshotExec = () => void | Promise<void>;
 
-type CaptureExec = (page: Puppeteer.Page) => Promise<void>;
-type CaptureSnapshots = Array<{ name: string, execute: CaptureExec }>;
+type AdditionalSnapshot = (XOR<XOR<
+  { name: string },
+  { prefix: string, suffix?: string }>,
+  { suffix: string, prefix?: string }>
+) & { execute: SnapshotExec };
 
 declare class Percy {
   static start(options?: PercyOptions): Promise<Percy>;
   constructor(options?: PercyOptions);
   loglevel(): LogLevel;
   loglevel(level: LogLevel): void;
-  isRunning(): boolean;
+  config: PercyConfigOptions;
+  setConfig(config: ClientEnvInfo & PercyConfigOptions): PercyConfigOptions;
   start(): Promise<void>;
-  stop(): Promise<void>;
+  stop(force?: boolean): Promise<void>;
   idle(): Promise<void>;
+  close(): void;
 
-  snapshot(options: SnapshotOptions & {
+  snapshot(options: {
     url: string,
-    name: string,
-    domSnapshot: string,
+    name?: string,
     clientInfo?: string,
     environmentInfo?: string
-  }): Promise<void>;
-
-  capture(options: SnapshotOptions & ({
-    url: string,
-    name: string,
-    snapshots?: CaptureSnapshots,
-    waitFor?: string | number,
-    execute?: CaptureExec,
-  } | {
-    url: string,
-    snapshots: CaptureSnapshots,
-    waitFor?: string | number,
-    execute?: CaptureExec
-  })): Promise<void>;
+  } & XOR<{
+    domSnapshot: string
+  }, {
+    waitForTimeout?: number,
+    waitForSelector?: string,
+    execute?: SnapshotExec,
+    additionalSnapshots?: AdditionalSnapshot[]
+  }> & SnapshotOptions): Promise<void>;
 }
 
 export default Percy;

package/dist/discoverer.js

@@ -1,367 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-
-var _puppeteerCore = _interopRequireDefault(require("puppeteer-core"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _queue2 = _interopRequireDefault(require("./queue"));
-
-var _assert = _interopRequireDefault(require("./utils/assert"));
-
-var _idle = _interopRequireDefault(require("./utils/idle"));
-
-var _installBrowser = _interopRequireDefault(require("./utils/install-browser"));
-
-var _resources = require("./utils/resources");
-
-var _url = require("./utils/url");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; }
-
-const REDIRECT_STATUSES = [301, 302, 304, 307, 308];
-const ALLOWED_STATUSES = [200, 201, ...REDIRECT_STATUSES]; // A PercyDiscoverer instance connects to a puppeteer browser and concurrently
-// discovers resources for snapshots. Resources are only captured from the
-// snapshot's root URL by default unless additional allowed hostnames are
-// defined. Captured resources are cached so future requests resolve much
-// quicker and snapshots can share cached resources.
-
-var _queue = new WeakMap();
-
-var _browser = new WeakMap();
-
-var _cache = new WeakMap();
-
-class PercyDiscoverer {
-  constructor({
-    // asset discovery concurrency
-    concurrency,
-    // additional allowed hostnames besides the root URL hostname
-    allowedHostnames,
-    // how long to wait before the network is considered to be idle and assets
-    // are determined to be fully discovered
-    networkIdleTimeout,
-    // disable resource caching, the cache is still used but overwritten for each resource
-    disableAssetCache,
-    // browser launch options
-    launchOptions
-  }) {
-    _queue.set(this, {
-      writable: true,
-      value: null
-    });
-
-    _browser.set(this, {
-      writable: true,
-      value: null
-    });
-
-    _cache.set(this, {
-      writable: true,
-      value: new Map()
-    });
-
-    _classPrivateFieldSet(this, _queue, new _queue2.default(concurrency));
-
-    Object.assign(this, {
-      allowedHostnames,
-      networkIdleTimeout,
-      disableAssetCache,
-      launchOptions
-    });
-  } // Returns true or false when the browser is connected.
-
-
-  isConnected() {
-    var _classPrivateFieldGet2;
-
-    return !!((_classPrivateFieldGet2 = _classPrivateFieldGet(this, _browser)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.isConnected());
-  } // Installs the browser executable if necessary and launches a Puppeteer
-  // browser instance for use during asset discovery.
-
-
-  async launch() {
-    var _this$launchOptions, _this$launchOptions2;
-
-    if (this.isConnected()) return;
-    let executablePath = await (0, _installBrowser.default)((_this$launchOptions = this.launchOptions) === null || _this$launchOptions === void 0 ? void 0 : _this$launchOptions.executablePath);
-
-    _classPrivateFieldSet(this, _browser, await _puppeteerCore.default.launch({ ...this.launchOptions,
-      ignoreHTTPSErrors: true,
-      handleSIGINT: false,
-      handleSIGTERM: false,
-      handleSIGHUP: false,
-      executablePath,
-      args: ['--no-sandbox', '--disable-web-security', ...(((_this$launchOptions2 = this.launchOptions) === null || _this$launchOptions2 === void 0 ? void 0 : _this$launchOptions2.args) || [])]
-    }));
-  } // Clears any unstarted discovery tasks and closes the browser.
-
-
-  async close() {
-    var _classPrivateFieldGet3;
-
-    _classPrivateFieldGet(this, _queue).clear();
-
-    await ((_classPrivateFieldGet3 = _classPrivateFieldGet(this, _browser)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.close());
-  } // Returns a new browser page.
-
-
-  async page() {
-    var _classPrivateFieldGet4;
-
-    return (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _browser)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.newPage();
-  } // Gathers resources for a root URL and DOM. The accumulator should be a Map
-  // and will be populated with resources by URL. Resolves when asset discovery
-  // finishes, although shouldn't be awaited on as discovery happens concurrently.
-
-
-  gatherResources(accumulator, {
-    rootUrl,
-    rootDom,
-    enableJavaScript,
-    requestHeaders,
-    width,
-    meta
-  }) {
-    (0, _assert.default)(this.isConnected(), 'Browser not connected'); // discover assets concurrently
-
-    return _classPrivateFieldGet(this, _queue).push(async () => {
-      _logger.default.debug(`Discovering resources @${width}px for ${rootUrl}`, {
-        url: rootUrl,
-        ...meta
-      }); // get a fresh page
-
-
-      let page = await this.page(); // track processing network requests
-
-      let processing = 0; // set page options
-
-      await page.setRequestInterception(true);
-      await page.setJavaScriptEnabled(enableJavaScript);
-      await page.setViewport({ ...page.viewport(),
-        width
-      });
-      await page.setExtraHTTPHeaders(requestHeaders); // add and configure request listeners
-
-      page.on('request', this._handleRequest({
-        onRequest: () => processing++,
-        rootUrl,
-        rootDom,
-        meta
-      })).on('requestfinished', this._handleRequestFinished({
-        onFinished: () => processing--,
-        accumulator,
-        rootUrl,
-        meta
-      })).on('requestfailed', this._handleRequestFailed({
-        onFailed: () => processing--,
-        meta
-      }));
-
-      try {
-        // navigate to the root URL and wait for the network to idle
-        await page.goto(rootUrl);
-        await (0, _idle.default)(() => processing, this.networkIdleTimeout);
-      } finally {
-        // cleanup
-        page.removeAllListeners('request');
-        page.removeAllListeners('requestfailed');
-        page.removeAllListeners('requestfinished');
-        await page.close();
-      }
-    });
-  } // Creates a request handler for the specific root URL and DOM. The handler
-  // will serve the root DOM for the root URL, respond with possible cached
-  // responses, skip resources that should not be captured, and abort requests
-  // that result in an error.
-
-
-  _handleRequest({
-    rootUrl,
-    rootDom,
-    onRequest,
-    meta
-  }) {
-    let allowedHostnames = [(0, _url.hostname)(rootUrl)].concat(this.allowedHostnames);
-    return request => {
-      let url = request.url();
-      onRequest(); // skip any logging and handling of data-urls
-
-      if (url.startsWith('data:')) {
-        return request.continue();
-      }
-
-      meta = { ...meta,
-        url
-      };
-
-      _logger.default.debug(`Handling request for ${url}`, meta);
-
-      try {
-        if (url === rootUrl) {
-          // root resource
-          _logger.default.debug(`Serving root resource for ${url}`, meta);
-
-          request.respond({
-            status: 200,
-            body: rootDom,
-            contentType: 'text/html'
-          });
-        } else if (!this.disableAssetCache && _classPrivateFieldGet(this, _cache).has(url)) {
-          // respond with cached response
-          _logger.default.debug(`Response cache hit for ${url}`, meta);
-
-          request.respond(_classPrivateFieldGet(this, _cache).get(url).response);
-        } else {
-          // do not resolve resources that should not be captured
-          (0, _assert.default)(allowedHostnames.some(h => (0, _url.domainMatch)(h, url)), 'is remote', meta); // continue the request
-
-          request.continue();
-        }
-      } catch (error) {
-        if (error.name === 'PercyAssertionError') {
-          _logger.default.debug(`Skipping - ${error.toString()}`, error.meta);
-        } else {
-          _logger.default.error(`Encountered an error for ${url}`, meta);
-
-          _logger.default.error(error);
-        } // request hangs without aborting on error
-
-
-        request.abort();
-      }
-    };
-  } // Creates a request finished handler for a specific root URL that will add
-  // resolved resources to an accumulator. Both the response and resource are
-  // cached for future snapshots and requests.
-
-
-  _handleRequestFinished({
-    rootUrl,
-    accumulator,
-    onFinished,
-    meta
-  }) {
-    return async request => {
-      let url = (0, _url.normalizeURL)(request.url());
-      meta = { ...meta,
-        url
-      };
-
-      try {
-        // do nothing for the root URL or URLs that start with `data:`
-        if (url === rootUrl || url.startsWith('data:')) return; // process and cache the response and resource
-
-        if (this.disableAssetCache || !_classPrivateFieldGet(this, _cache).has(url)) {
-          _logger.default.debug(`Processing resource - ${url}`, meta);
-
-          let response = await this._parseRequestResponse(url, request, meta);
-          let mimetype = response.headers['content-type'][0].split(';')[0];
-          let resource = (0, _resources.createLocalResource)(url, response.body, mimetype, () => {
-            _logger.default.debug(`Making local copy of response - ${url}`, meta);
-          });
-
-          _logger.default.debug(`-> url: ${url}`, meta);
-
-          _logger.default.debug(`-> sha: ${resource.sha}`, meta);
-
-          _logger.default.debug(`-> filepath: ${resource.filepath}`, meta);
-
-          _logger.default.debug(`-> mimetype: ${resource.mimetype}`, meta);
-
-          _classPrivateFieldGet(this, _cache).set(url, {
-            response,
-            resource
-          });
-        } // add the resource to the accumulator
-
-
-        accumulator.set(url, _classPrivateFieldGet(this, _cache).get(url).resource);
-      } catch (error) {
-        if (error.name === 'PercyAssertionError') {
-          _logger.default.debug(`Skipping - ${error.toString()}`, error.meta);
-        } else {
-          _logger.default.error(`Encountered an error for ${url}`, meta);
-
-          _logger.default.error(error);
-        }
-      } finally {
-        onFinished();
-      }
-    };
-  } // Creates a failed request handler that logs non-generic failure reasons.
-
-
-  _handleRequestFailed({
-    onFailed,
-    meta
-  }) {
-    return req => {
-      let error = req.failure().errorText; // do not log generic failures since the real error was most likely
-      // already logged from elsewhere
-
-      if (error !== 'net::ERR_FAILED') {
-        _logger.default.debug(`Request failed for ${req.url()} - ${error}`, meta);
-      }
-
-      onFailed();
-    };
-  } // Parses a request's response to find the status, headers, and body. Performs
-  // various response assertions and follows redirect requests using node-fetch.
-
-
-  async _parseRequestResponse(url, request, meta) {
-    let headers, body;
-    let response = request.response();
-    (0, _assert.default)(response, 'no response', meta);
-    let status = response.status();
-    (0, _assert.default)(ALLOWED_STATUSES.includes(status), 'disallowed status', {
-      status,
-      ...meta
-    });
-
-    if (REDIRECT_STATUSES.includes(status)) {
-      // fetch's default max redirect length is 20
-      let length = request.redirectChain().length;
-      (0, _assert.default)(length <= 20, 'too many redirects', {
-        length,
-        ...meta
-      });
-      let redirect = await (0, _nodeFetch.default)(response.url(), {
-        responseType: 'arraybuffer',
-        headers: request.headers()
-      });
-      headers = redirect.headers.raw();
-      body = await redirect.buffer();
-    } else {
-      // CDP returns multiple headers joined by newlines, however
-      // `request.respond` (used for cached responses) will hang if there are
-      // newlines in headers. The following reduction normalizes header values
-      // as arrays split on newlines
-      headers = Object.entries(response.headers()).reduce((norm, [key, value]) => Object.assign(norm, {
-        [key]: value.split('\n')
-      }), {});
-      body = await response.buffer();
-    }
-
-    (0, _assert.default)(body.toString(), 'is empty', meta);
-    return {
-      status,
-      headers,
-      body
-    };
-  }
-
-}
-
-exports.default = PercyDiscoverer;

package/dist/percy-css.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = injectPercyCSS;
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _resources = require("./utils/resources");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// Creates a local Percy CSS resource and injects a Percy CSS link into the
-// provided DOM string. Returns both the new DOM string and local resource
-// object. If no Percy CSS is provided the return value will be the original DOM
-// string and the function will do nothing.
-function injectPercyCSS(rootUrl, originalDOM, percyCSS, meta) {
-  if (!percyCSS) return [originalDOM];
-  let filename = `percy-specific.${Date.now()}.css`;
-
-  _logger.default.debug('Handling percy-specific css:', meta);
-
-  _logger.default.debug(`-> filename: ${filename}`, meta);
-
-  _logger.default.debug(`-> content: ${percyCSS}`, meta);
-
-  let url = `${rootUrl}/${filename}`;
-  let resource = (0, _resources.createLocalResource)(url, percyCSS, 'text/css', null, meta);
-  let link = `<link data-percy-specific-css rel="stylesheet" href="/${filename}"/>`;
-  let dom = originalDOM.replace(/(<\/body>)(?!.*\1)/is, link + '$&');
-  return [dom, resource];
-}

package/dist/utils/assert.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = percyAssert;
-
-var _assert = require("assert");
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-// Percy assertions errors contain extra meta data and have specific lookup keys
-// for different computed assertion error messages.
-class PercyAssertionError extends Error {
-  constructor(lookup, meta = {}) {
-    var _PercyAssertionError$, _PercyAssertionError$2, _PercyAssertionError$3;
-
-    super((_PercyAssertionError$ = (_PercyAssertionError$2 = (_PercyAssertionError$3 = PercyAssertionError.dict)[lookup]) === null || _PercyAssertionError$2 === void 0 ? void 0 : _PercyAssertionError$2.call(_PercyAssertionError$3, meta)) !== null && _PercyAssertionError$ !== void 0 ? _PercyAssertionError$ : lookup);
-    this.name = this.constructor.name;
-    this.meta = meta;
-  }
-
-  toString() {
-    return this.message;
-  }
-
-} // Wraps native assert to throw a Percy assertion error with optional meta.
-
-
-_defineProperty(PercyAssertionError, "dict", {
-  'disallowed status': ({
-    status
-  }) => `Disallowed response status [${status}]`,
-  'is empty': () => 'Empty response',
-  'is remote': () => 'Remote resource',
-  'no response': () => 'No response',
-  'too many bytes': ({
-    size
-  }) => `Max file size exceeded [${size}]`,
-  'too many redirects': ({
-    length
-  }) => `Too many redirects [${length}]`,
-  'too many widths': ({
-    widths
-  }) => `Too many widths requested: maximum is 10, requested ${widths}`
-});
-
-function percyAssert(condition, lookup, meta) {
-  (0, _assert.strict)(condition, new PercyAssertionError(lookup, meta));
-}

package/dist/utils/bytes.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = readableBytes;
-
-// Converts a raw byte integer into a human readable string.
-function readableBytes(bytes) {
-  let units = ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
-  let thresh = 1024;
-  let u = -1;
-
-  if (Math.abs(bytes) < thresh) {
-    return `${bytes}B`;
-  }
-
-  while (Math.abs(bytes) >= thresh && u < units.length - 1) {
-    bytes /= thresh;
-    ++u;
-  }
-
-  return `${bytes.toFixed(1)}${units[u]}`;
-}

package/dist/utils/idle.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = idle;
-
-// Returns a promise that resolves when the `count` function returns `0`. If
-// `count` returns non-zero, will check again after `timeout`. The `count`
-// function must eventually return `0` or the promise will never resolve.
-function idle(count, timeout = 10) {
-  return new Promise(resolve => function check() {
-    if (count() === 0) resolve();else setTimeout(check, timeout);
-  }());
-}