@percy/sdk-utils 1.8.1 → 1.10.0

package/dist/bundle.js

@@ -107,26 +107,26 @@
           log: [ns, lvl, msg, meta]
         }));
       } else {
-        // keep log history when not remote
-        let [debug, level, message, timestamp] = [ns, lvl, msg, Date.now()];
+        // keep log history of full message when not remote
+        let message = err ? msg.stack : msg.toString();
+        let [debug, level, timestamp, error] = [ns, lvl, Date.now(), !!err];
         (log.history || (log.history = [])).push({
           debug,
           level,
           message,
           meta,
-          timestamp
+          timestamp,
+          error
         });
       } // check if the specific level is within the local loglevel range
 
 
       if (LOG_LEVELS[lvl] != null && LOG_LEVELS[lvl] >= LOG_LEVELS[loglevel()]) {
-        var _msg;
-
         let debug = loglevel() === 'debug';
         let label = debug ? `percy:${ns}` : 'percy'; // colorize the label when possible for consistency with the CLI logger
 
         if (!process.env.__PERCY_BROWSERIFIED__) label = `\u001b[95m${label}\u001b[39m`;
-        msg = `[${label}] ${err && debug && ((_msg = msg) === null || _msg === void 0 ? void 0 : _msg.stack) || msg}`;
+        msg = `[${label}] ${err && debug && msg.stack || msg}`;
 
         if (process.env.__PERCY_BROWSERIFIED__) {
           // use console[warn|error|log] in browsers
@@ -172,15 +172,17 @@
 
         let address = new URL('/logger', info.address).href; // create and cache a websocket connection
 
-        let ws = remote.socket = await createWebSocket(address, timeout); // accept loglevel updates
-
-        /* istanbul ignore next: difficult to test currently */
-
-        ws.onmessage = e => loglevel(JSON.parse(e.data).loglevel); // cleanup message handler on close
-
-
-        ws.onclose = () => remote.socket = ws.onmessage = ws.onclose = null; // send any messages already logged in this environment
+        let ws = remote.socket = await createWebSocket(address, timeout);
+        await new Promise((resolve, reject) => {
+          // accept loglevel updates and resolve after first message
+          ws.onmessage = e => resolve(loglevel(JSON.parse(e.data).loglevel));
 
+          ws.onclose = () => {
+            // cleanup listeners and reject if not resolved
+            remote.socket = ws.onmessage = ws.onclose = null;
+            reject(new Error('Connection closed'));
+          };
+        }); // send any messages already logged in this environment
 
         if (log.history) ws.send(JSON.stringify({
           messages: log.history
@@ -205,7 +207,9 @@
 
       if (!(response.status >= 200 && response.status < 300)) {
         throw Object.assign(new Error(), {
-          message: response.body.error || `${response.status} ${response.statusText}`,
+          message: response.body.error ||
+          /* istanbul ignore next: in tests, there's always an error message */
+          `${response.status} ${response.statusText}`,
           response
         });
       }

package/dist/logger.js

@@ -52,26 +52,26 @@ const log = logger.log = (ns, lvl, msg, meta) => {
       log: [ns, lvl, msg, meta]
     }));
   } else {
-    // keep log history when not remote
-    let [debug, level, message, timestamp] = [ns, lvl, msg, Date.now()];
+    // keep log history of full message when not remote
+    let message = err ? msg.stack : msg.toString();
+    let [debug, level, timestamp, error] = [ns, lvl, Date.now(), !!err];
     (log.history || (log.history = [])).push({
       debug,
       level,
       message,
       meta,
-      timestamp
+      timestamp,
+      error
     });
   } // check if the specific level is within the local loglevel range
 
 
   if (LOG_LEVELS[lvl] != null && LOG_LEVELS[lvl] >= LOG_LEVELS[loglevel()]) {
-    var _msg;
-
     let debug = loglevel() === 'debug';
     let label = debug ? `percy:${ns}` : 'percy'; // colorize the label when possible for consistency with the CLI logger
 
     if (!process.env.__PERCY_BROWSERIFIED__) label = `\u001b[95m${label}\u001b[39m`;
-    msg = `[${label}] ${err && debug && ((_msg = msg) === null || _msg === void 0 ? void 0 : _msg.stack) || msg}`;
+    msg = `[${label}] ${err && debug && msg.stack || msg}`;
 
     if (process.env.__PERCY_BROWSERIFIED__) {
       // use console[warn|error|log] in browsers
@@ -116,15 +116,17 @@ const remote = logger.remote = async timeout => {
 
     let address = new URL('/logger', _percyInfo.default.address).href; // create and cache a websocket connection
 
-    let ws = remote.socket = await createWebSocket(address, timeout); // accept loglevel updates
-
-    /* istanbul ignore next: difficult to test currently */
-
-    ws.onmessage = e => loglevel(JSON.parse(e.data).loglevel); // cleanup message handler on close
-
-
-    ws.onclose = () => remote.socket = ws.onmessage = ws.onclose = null; // send any messages already logged in this environment
-
+    let ws = remote.socket = await createWebSocket(address, timeout);
+    await new Promise((resolve, reject) => {
+      // accept loglevel updates and resolve after first message
+      ws.onmessage = e => resolve(loglevel(JSON.parse(e.data).loglevel));
+
+      ws.onclose = () => {
+        // cleanup listeners and reject if not resolved
+        remote.socket = ws.onmessage = ws.onclose = null;
+        reject(new Error('Connection closed'));
+      };
+    }); // send any messages already logged in this environment
 
     if (log.history) ws.send(JSON.stringify({
       messages: log.history

package/dist/request.js

@@ -27,7 +27,9 @@ async function request(path, options = {}) {
 
   if (!(response.status >= 200 && response.status < 300)) {
     throw Object.assign(new Error(), {
-      message: response.body.error || `${response.status} ${response.statusText}`,
+      message: response.body.error ||
+      /* istanbul ignore next: in tests, there's always an error message */
+      `${response.status} ${response.statusText}`,
       response
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/sdk-utils",
-  "version": "1.8.1",
+  "version": "1.10.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,8 +26,6 @@
       "node": "./dist/index.js",
       "default": "./dist/bundle.js"
     },
-    "./test/server": "./test/server.js",
-    "./test/client": "./test/client.js",
     "./test/helpers": {
       "node": "./test/helpers.js",
       "default": "./test/client.js"
@@ -36,13 +34,9 @@
   "scripts": {
     "build": "node ../../scripts/build",
     "lint": "eslint --ignore-path ../../.gitignore .",
-    "test": "node ../../scripts/test",
+    "test": "percy exec --testing -- node ../../scripts/test",
     "test:coverage": "yarn test --coverage"
   },
-  "karma": {
-    "run_start": "node test/server start",
-    "run_complete": "node test/server stop"
-  },
   "rollup": {
     "external": [
       "ws"
@@ -56,5 +50,5 @@
       ]
     }
   },
-  "gitHead": "497772c62e2fa2d763b350c40a0cfec918f7125f"
+  "gitHead": "a6934eda4fc3b84845ae606d7f5a901f25e0a56f"
 }

package/test/client.js

@@ -14,206 +14,36 @@
     var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 
     const utils = require$$0__default["default"];
-
-    function stub(object, method, func) {
-      if (object[method].restore) object[method].restore();
-      let stub = object[method] = Object.assign(function stub() {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-
-        stub.calls.push(args);
-        if (func) return func.apply(this, args);
-      }, {
-        restore: () => object[method] = stub.originalValue,
-        reset: () => (stub.calls.length = 0) || stub,
-        originalValue: object[method],
-        calls: []
-      });
-      return stub;
-    } // matches ansi escape sequences
-
-
-    const ANSI_REG = new RegExp('[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', 'g'); // strips a log message of excessive newlines and asni escape sequences
-
-    function sanitizeLog(str) {
-      return str.replace(/\r\n/g, '\n').replace(ANSI_REG, '').replace(/\n$/, '');
-    }
-
     const helpers = {
-      async setup() {
+      async setupTest() {
         utils.percy.version = '';
         delete utils.percy.config;
         delete utils.percy.enabled;
         delete utils.percy.domScript;
+        delete utils.logger.log.history;
+        delete utils.logger.loglevel.lvl;
+        delete process.env.PERCY_LOGLEVEL;
         delete process.env.PERCY_SERVER_ADDRESS;
-        await helpers.call('server.mock');
-        await helpers.logger.mock();
+        await helpers.test('reset');
+        await utils.logger.remote();
       },
 
-      async teardown() {
-        var _utils$logger$log$res, _utils$logger$log;
-
-        (_utils$logger$log$res = (_utils$logger$log = utils.logger.log).restore) === null || _utils$logger$log$res === void 0 ? void 0 : _utils$logger$log$res.call(_utils$logger$log);
-
-        if (process.env.__PERCY_BROWSERIFIED__) {
-          for (let m of ['warn', 'error', 'log']) {
-            var _console$m$restore, _console$m;
-
-            (_console$m$restore = (_console$m = console[m]).restore) === null || _console$m$restore === void 0 ? void 0 : _console$m$restore.call(_console$m);
-          }
-        } else {
-          for (let io of ['stdout', 'stderr']) {
-            var _process$io$write$res, _process$io$write;
-
-            (_process$io$write$res = (_process$io$write = process[io].write).restore) === null || _process$io$write$res === void 0 ? void 0 : _process$io$write$res.call(_process$io$write);
-          }
-        }
-
-        return helpers.call('server.close');
+      async test(cmd, arg) {
+        let res = await utils.request.post(`/test/api/${cmd}`, arg);
+        return res.body;
       },
 
-      getRequests: () => helpers.call('server.requests'),
-      testReply: (path, reply) => helpers.call('server.reply', path, reply),
-      testFailure: function () {
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          args[_key2] = arguments[_key2];
-        }
-
-        return helpers.call('server.test.failure', ...args);
+      async get(what, map) {
+        let res = await utils.request(`/test/${what}`);
+        if (!map) map = what === 'logs' ? l => l.message : i => i;
+        return Array.isArray(res.body[what]) ? res.body[what].map(map) : map(res.body);
       },
-      testError: path => helpers.call('server.test.error', path),
-      testSerialize: fn => !fn ? helpers.call('server.test.serialize') // get
-      : helpers.call('server.test.serialize', fn),
-      // set
-      mockSite: () => helpers.call('site.mock'),
-      closeSite: () => helpers.call('site.close'),
-      logger: {
-        stdout: [],
-        stderr: [],
-        loglevel: utils.logger.loglevel,
-
-        async mock() {
-          helpers.logger.reset();
-          let shouldCaptureLogs = false;
-          stub(utils.logger, 'log', function () {
-            shouldCaptureLogs = true;
-            utils.logger.log.originalValue(...arguments);
-            shouldCaptureLogs = false;
-          });
-
-          let stubLogs = (ctx, method, err) => stub(ctx, method, msg => {
-            if (!shouldCaptureLogs) return ctx[method].originalValue.call(ctx, msg);else helpers.logger[err ? 'stderr' : 'stdout'].push(sanitizeLog(msg));
-          });
-
-          if (process.env.__PERCY_BROWSERIFIED__) {
-            for (let m of ['warn', 'error', 'log']) stubLogs(console, m, m !== 'log');
-          } else {
-            for (let io of ['stdout', 'stderr']) stubLogs(process[io], 'write', io === 'stderr');
-          }
-        },
-
-        reset() {
-          var _utils$logger$remote$, _utils$logger$log$res2, _utils$logger$log2;
-
-          (_utils$logger$remote$ = utils.logger.remote.socket) === null || _utils$logger$remote$ === void 0 ? void 0 : _utils$logger$remote$.close();
-          delete utils.logger.loglevel.lvl;
-          delete utils.logger.log.history;
-          helpers.logger.stdout.length = 0;
-          helpers.logger.stderr.length = 0;
-          (_utils$logger$log$res2 = (_utils$logger$log2 = utils.logger.log).reset) === null || _utils$logger$log$res2 === void 0 ? void 0 : _utils$logger$log$res2.call(_utils$logger$log2);
-
-          if (process.env.__PERCY_BROWSERIFIED__) {
-            for (let m of ['warn', 'error', 'log']) {
-              var _console$m$reset, _console$m2;
-
-              (_console$m$reset = (_console$m2 = console[m]).reset) === null || _console$m$reset === void 0 ? void 0 : _console$m$reset.call(_console$m2);
-            }
-          } else {
-            for (let io of ['stdout', 'stderr']) {
-              var _process$io$write$res2, _process$io$write2;
-
-              (_process$io$write$res2 = (_process$io$write2 = process[io].write).reset) === null || _process$io$write$res2 === void 0 ? void 0 : _process$io$write$res2.call(_process$io$write2);
-            }
-          }
-        }
 
+      get testSnapshotURL() {
+        return `${utils.percy.address}/test/snapshot`;
       }
-    };
-
-    if (process.env.__PERCY_BROWSERIFIED__) {
-      helpers.call = async function call(event) {
-        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-          args[_key3 - 1] = arguments[_key3];
-        }
-
-        let {
-          socket,
-          pending = {}
-        } = helpers.call;
-
-        if (!socket) {
-          socket = new window.WebSocket('ws://localhost:5339');
-          await new Promise((resolve, reject) => {
-            let done = event => {
-              clearTimeout(timeoutid);
-              socket.onopen = socket.onerror = null;
-
-              if (event && (event.error || event.type === 'error')) {
-                reject(event.error || new Error('Test client connection failed'));
-              } else resolve(socket);
-            };
-
-            let timeoutid = setTimeout(done, 1000, {
-              error: new Error('Test client connection timed out')
-            });
-            socket.onopen = socket.onerror = done;
-          });
-
-          socket.onmessage = _ref => {
-            let {
-              data
-            } = _ref;
-            let {
-              id,
-              resolve,
-              reject
-            } = JSON.parse(data);
-            if (!pending[id]) return;
-            if (resolve) pending[id].resolve(resolve.result);
-            if (reject) pending[id].reject(reject.error);
-          };
-
-          Object.assign(helpers.call, {
-            socket,
-            pending
-          });
-        }
-
-        let id = helpers.call.uid = (helpers.call.uid || 0) + 1;
-        args = args.map(a => typeof a === 'function' ? a.toString() : a);
-        socket.send(JSON.stringify({
-          id,
-          event,
-          args
-        }));
-        return (pending[id] = {}).promise = new Promise((resolve, reject) => {
-          Object.assign(pending[id], {
-            resolve,
-            reject
-          });
-        });
-      };
-    } else {
-      helpers.call = async function call() {
-        let {
-          context
-        } = await ({});
-        helpers.context = helpers.context || (await context());
-        return helpers.context.call(...arguments);
-      };
-    }
 
+    };
     var helpers_1 = helpers;
 
     return helpers_1;

package/test/helpers.js

@@ -1,162 +1,33 @@
 const utils = require('@percy/sdk-utils');
 
-function stub(object, method, func) {
-  if (object[method].restore) object[method].restore();
-
-  let stub = object[method] = Object.assign(function stub(...args) {
-    stub.calls.push(args);
-    if (func) return func.apply(this, args);
-  }, {
-    restore: () => (object[method] = stub.originalValue),
-    reset: () => (stub.calls.length = 0) || stub,
-    originalValue: object[method],
-    calls: []
-  });
-
-  return stub;
-}
-
-// matches ansi escape sequences
-const ANSI_REG = new RegExp((
-  '[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' +
-  '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
-), 'g');
-
-// strips a log message of excessive newlines and asni escape sequences
-function sanitizeLog(str) {
-  return str.replace(/\r\n/g, '\n')
-    .replace(ANSI_REG, '')
-    .replace(/\n$/, '');
-}
-
 const helpers = {
-  async setup() {
+  async setupTest() {
     utils.percy.version = '';
     delete utils.percy.config;
     delete utils.percy.enabled;
     delete utils.percy.domScript;
+    delete utils.logger.log.history;
+    delete utils.logger.loglevel.lvl;
+    delete process.env.PERCY_LOGLEVEL;
     delete process.env.PERCY_SERVER_ADDRESS;
-    await helpers.call('server.mock');
-    await helpers.logger.mock();
+    await helpers.test('reset');
+    await utils.logger.remote();
   },
 
-  async teardown() {
-    utils.logger.log.restore?.();
-
-    if (process.env.__PERCY_BROWSERIFIED__) {
-      for (let m of ['warn', 'error', 'log']) console[m].restore?.();
-    } else {
-      for (let io of ['stdout', 'stderr']) process[io].write.restore?.();
-    }
-
-    return helpers.call('server.close');
+  async test(cmd, arg) {
+    let res = await utils.request.post(`/test/api/${cmd}`, arg);
+    return res.body;
   },
 
-  getRequests: () => helpers.call('server.requests'),
-  testReply: (path, reply) => helpers.call('server.reply', path, reply),
-  testFailure: (...args) => helpers.call('server.test.failure', ...args),
-  testError: path => helpers.call('server.test.error', path),
-  testSerialize: fn => !fn
-    ? helpers.call('server.test.serialize') // get
-    : helpers.call('server.test.serialize', fn), // set
-  mockSite: () => helpers.call('site.mock'),
-  closeSite: () => helpers.call('site.close'),
-
-  logger: {
-    stdout: [],
-    stderr: [],
-    loglevel: utils.logger.loglevel,
-
-    async mock() {
-      helpers.logger.reset();
-
-      let shouldCaptureLogs = false;
-
-      stub(utils.logger, 'log', (...args) => {
-        shouldCaptureLogs = true;
-        utils.logger.log.originalValue(...args);
-        shouldCaptureLogs = false;
-      });
-
-      let stubLogs = (ctx, method, err) => stub(ctx, method, msg => {
-        if (!shouldCaptureLogs) return ctx[method].originalValue.call(ctx, msg);
-        else helpers.logger[err ? 'stderr' : 'stdout'].push(sanitizeLog(msg));
-      });
-
-      if (process.env.__PERCY_BROWSERIFIED__) {
-        for (let m of ['warn', 'error', 'log']) stubLogs(console, m, m !== 'log');
-      } else {
-        for (let io of ['stdout', 'stderr']) stubLogs(process[io], 'write', io === 'stderr');
-      }
-    },
-
-    reset() {
-      utils.logger.remote.socket?.close();
-      delete utils.logger.loglevel.lvl;
-      delete utils.logger.log.history;
-
-      helpers.logger.stdout.length = 0;
-      helpers.logger.stderr.length = 0;
-      utils.logger.log.reset?.();
+  async get(what, map) {
+    let res = await utils.request(`/test/${what}`);
+    if (!map) map = what === 'logs' ? (l => l.message) : (i => i);
+    return Array.isArray(res.body[what]) ? res.body[what].map(map) : map(res.body);
+  },
 
-      if (process.env.__PERCY_BROWSERIFIED__) {
-        for (let m of ['warn', 'error', 'log']) console[m].reset?.();
-      } else {
-        for (let io of ['stdout', 'stderr']) process[io].write.reset?.();
-      }
-    }
+  get testSnapshotURL() {
+    return `${utils.percy.address}/test/snapshot`;
   }
 };
 
-if (process.env.__PERCY_BROWSERIFIED__) {
-  helpers.call = async function call(event, ...args) {
-    let { socket, pending = {} } = helpers.call;
-
-    if (!socket) {
-      socket = new window.WebSocket('ws://localhost:5339');
-
-      await new Promise((resolve, reject) => {
-        let done = event => {
-          clearTimeout(timeoutid);
-          socket.onopen = socket.onerror = null;
-          if (event && (event.error || event.type === 'error')) {
-            reject(event.error || new Error('Test client connection failed'));
-          } else resolve(socket);
-        };
-
-        let timeoutid = setTimeout(done, 1000, {
-          error: new Error('Test client connection timed out')
-        });
-
-        socket.onopen = socket.onerror = done;
-      });
-
-      socket.onmessage = ({ data }) => {
-        let { id, resolve, reject } = JSON.parse(data);
-        if (!pending[id]) return;
-        if (resolve) pending[id].resolve(resolve.result);
-        if (reject) pending[id].reject(reject.error);
-      };
-
-      Object.assign(helpers.call, { socket, pending });
-    }
-
-    let id = helpers.call.uid = (helpers.call.uid || 0) + 1;
-    args = args.map(a => typeof a === 'function' ? a.toString() : a);
-    socket.send(JSON.stringify({ id, event, args }));
-
-    return ((pending[id] = {}).promise = (
-      new Promise((resolve, reject) => {
-        Object.assign(pending[id], { resolve, reject });
-      })
-    ));
-  };
-} else {
-  helpers.call = async function call() {
-    let { context } = await import('./server.js');
-    helpers.context = (helpers.context || await context());
-    return helpers.context.call(...arguments);
-  };
-}
-
 module.exports = helpers;

package/test/server.js

@@ -1,205 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-// create a testing context for mocking the local percy server and a local testing site
-async function context() {
-  let { createTestServer } = await import('@percy/core/test/helpers/server');
-
-  let ctx = {
-    async call(path, ...args) {
-      let [key, ...paths] = path.split('.').reverse();
-      let subject = paths.reduceRight((c, k) => c && c[k], ctx);
-      if (!subject) return;
-
-      let { value, get, set } = (
-        Object.getOwnPropertyDescriptor(subject, key) ||
-        Object.getOwnPropertyDescriptor(Object.getPrototypeOf(subject), key)
-      ) || {};
-
-      if (typeof value === 'function') {
-        value = await value.apply(subject, args);
-      } else if (!get && !set && args.length) {
-        value = subject[key] = args[0];
-      } else if (set && args.length) {
-        value = set.apply(subject, args);
-      } else if (get) {
-        value = get.apply(subject);
-      }
-
-      if (value && typeof value[Symbol.iterator] === 'function') {
-        value = Array.from(value);
-      }
-
-      return value;
-    }
-  };
-
-  let mockServer = async () => {
-    let allowSocketConnections = false;
-
-    let serializeDOM = options => {
-      let { dom = document, domTransformation } = options || {};
-      let doc = (dom || document).cloneNode(true).documentElement;
-      if (domTransformation) domTransformation(doc);
-      return doc.outerHTML;
-    };
-
-    if (ctx.server.close) ctx.server.close();
-
-    ctx.server = await createTestServer({
-      '/percy/dom.js': () => [200, 'application/javascript', (
-        `window.PercyDOM = { serialize: ${serializeDOM} }`)],
-      '/percy/healthcheck': () => [200, 'application/json', (
-        { success: true, config: { snapshot: { widths: [1280] } } })],
-      '/percy/config': ({ body }) => [200, 'application/json', (
-        { success: true, config: body })],
-      '/percy/snapshot': () => [200, 'application/json', { success: true }],
-      '/percy/idle': () => [200, 'application/json', { success: true }]
-    }, 5338);
-
-    ctx.server.route((req, res, next) => {
-      if (req.body) try { req.body = JSON.parse(req.body); } catch {}
-      res.setHeader('Access-Control-Expose-Headers', '*, X-Percy-Core-Version');
-      res.setHeader('X-Percy-Core-Version', ctx.server.version || '1.0.0');
-      return next();
-    });
-
-    ctx.server.websocket('/(logger)?', ws => {
-      if (!allowSocketConnections) return ws.terminate();
-      ws.onmessage = ({ data }) => ctx.server.messages.push(data);
-    });
-
-    Object.assign(ctx.server, {
-      mock: mockServer,
-      messages: [],
-
-      test: {
-        get serialize() { return serializeDOM; },
-        set serialize(fn) { return (serializeDOM = fn); },
-        failure: (path, error, o) => ctx.server.reply(path, () => (
-          [500, 'application/json', { success: false, error, ...o }])),
-        error: path => ctx.server.reply(path, r => r.connection.destroy()),
-        remote: () => (allowSocketConnections = true)
-      }
-    });
-  };
-
-  let mockSite = async () => {
-    if (ctx.site.close) ctx.site.close();
-    ctx.site = Object.assign(await createTestServer({
-      default: () => [200, 'text/html', 'Snapshot Me']
-    }), { mock: mockSite });
-  };
-
-  ctx.server = { mock: mockServer };
-  ctx.site = { mock: mockSite };
-
-  ctx.mockAll = () => Promise.all([
-    ctx.server.mock(),
-    ctx.site.mock()
-  ]);
-
-  ctx.close = () => {
-    if (ctx.server.close) ctx.server.close();
-    if (ctx.site.close) ctx.site.close();
-  };
-
-  return ctx;
-}
-
-// start a testing server to control a context remotely
-async function start(args) {
-  let { logger } = await import('@percy/logger');
-  let { WebSocketServer } = await import('ws');
-  let log = logger('utils:test/server');
-
-  let startSocketServer = (tries = 0) => new Promise((resolve, reject) => {
-    let server = new WebSocketServer({ port: 5339 });
-    server.on('listening', () => resolve(server)).on('error', reject);
-  }).catch(err => {
-    if (err.code === 'EADDRINUSE' && tries < 10) {
-      return stop().then(() => startSocketServer(++tries));
-    } else throw err;
-  });
-
-  let wss = await startSocketServer();
-  let ctx = await context();
-
-  let close = () => {
-    if (close.called) return;
-    close.called = true;
-
-    if (ctx) ctx.call('close');
-    for (let ws of wss.clients) ws.terminate();
-    wss.close(() => log.info('Closed SDK testing server'));
-  };
-
-  wss.on('connection', ws => {
-    ws.on('message', data => {
-      if (data.toString() === 'CLOSE') return close();
-      let { id, event, args = [] } = JSON.parse(data);
-
-      Promise.resolve().then(async () => {
-        let result = await ctx.call(event, ...args);
-        if (typeof result === 'function') result = result.toString();
-        ws.send(JSON.stringify({ id, resolve: { result } }));
-        log('debug', `${event}: ${JSON.stringify({ args, result })}`);
-      }).catch(err => {
-        let error = { message: err.message, stack: err.stack };
-        ws.send(JSON.stringify({ id, reject: { error } }));
-        log.debug(`${event}: ${error.stack}`);
-      });
-    });
-  });
-
-  await ctx.call('mockAll');
-  log.info('Started SDK testing server');
-}
-
-// stop any existing testing server
-async function stop() {
-  let { default: WS } = await import('ws');
-
-  await new Promise(resolve => {
-    let ws = new WS('ws://localhost:5339');
-    ws.on('open', () => ws.send('CLOSE'));
-    ws.on('close', () => resolve());
-  });
-}
-
-// start & stop a testing server around a command
-async function exec(args) {
-  let argsep = args.indexOf('--');
-  if (argsep < 0) throw new Error('Must supply a command after `--`');
-
-  let { spawn } = await import('child_process');
-  let [cmd, ...cmdargs] = args.slice(argsep + 1);
-  let startargs = args.slice(0, argsep);
-  await start(startargs);
-
-  spawn(cmd, cmdargs, { stdio: 'inherit' })
-    .on('exit', process.exit)
-    .on('error', error => {
-      console.error(error);
-      process.exit(1);
-    });
-}
-
-// allow invoking start/stop/exec as CLI commands
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const run = { start, stop, exec }[args[0]];
-
-  if (!run) {
-    process.stderr.write('usage: node test/server <start|stop|exec>\n');
-  } else if (!process.send && fs.existsSync(path.join(__filename, '../../src'))) {
-    import('child_process').then(cp => cp.fork(__filename, args, {
-      execArgv: ['--no-warnings', '--loader=../../scripts/loader.js']
-    }));
-  } else {
-    run(args.slice(1)).catch(console.error);
-  }
-}
-
-// export the namespace by default
-module.exports = { context, start, stop, exec };