@percy/sdk-utils 1.1.0 → 1.1.3

package/test/client.js

@@ -1,6 +1,6 @@
 (function() {
   this["null"] = this["null"] || {};
-  this.PercySDKUtils.TestHelpers = (function (logger, utils) {
+  this.PercySDKUtils.TestHelpers = (function (require$$0) {
     'use strict';
 
     const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
@@ -11,180 +11,73 @@
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-    var logger__default = /*#__PURE__*/_interopDefaultLegacy(logger);
-    var utils__default = /*#__PURE__*/_interopDefaultLegacy(utils);
+    var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 
-    const {
-      assign,
-      entries
-    } = Object; // matches ansi escape sequences
+    const utils = require$$0__default["default"];
 
-    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'); // color names by ansi escape code
-
-    const ANSI_COLORS = {
-      '91m': 'red',
-      '32m': 'green',
-      '93m': 'yellow',
-      '34m': 'blue',
-      '95m': 'magenta',
-      '90m': 'grey'
-    }; // colorize each line of a string using an ansi escape sequence
-
-    const LINE_REG = /^.*$/gm;
-
-    function colorize(code, str) {
-      return str.replace(LINE_REG, line => `\u001b[${code}${line}\u001b[39m`);
-    } // map ansi colors to bound colorize functions
-
-
-    entries(ANSI_COLORS).reduce((colors, _ref) => {
-      let [code, name] = _ref;
-      return assign(colors, {
-        [name]: colorize.bind(null, code)
-      });
-    }, {});
-
-    const ELAPSED_REG = /\s\S*?\(\d+ms\)\S*/;
-    const NEWLINE_REG = /\r\n/g;
-    const LASTLINE_REG = /\n$/;
-
-    function sanitizeLog(str) {
-      let {
-        ansi,
-        elapsed
-      } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      // normalize line endings
-      str = str.replace(NEWLINE_REG, '\n'); // strip ansi colors
-
-      if (!ansi) str = str.replace(ANSI_REG, ''); // strip elapsed time
-
-      if (!elapsed) str = str.replace(ELAPSED_REG, ''); // strip trailing line endings
-
-      return str.replace(LASTLINE_REG, '');
-    }
-
-    function spy(object, method, func) {
+    function stub(object, method, func) {
       if (object[method].restore) object[method].restore();
-      let spy = Object.assign(function spy() {
+      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];
         }
 
-        spy.calls.push(args);
+        stub.calls.push(args);
         if (func) return func.apply(this, args);
       }, {
-        restore: () => object[method] = spy.originalValue,
-        reset: () => (spy.calls.length = 0) || spy,
+        restore: () => object[method] = stub.originalValue,
+        reset: () => (stub.calls.length = 0) || stub,
         originalValue: object[method],
         calls: []
       });
-      object[method] = spy;
-      return spy;
-    }
-
-    const {
-      Logger,
-      loglevel
-    } = logger__default["default"];
-    const helpers$1 = {
-      stdout: [],
-      stderr: [],
-      loglevel,
-
-      async mock() {
-        let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        helpers$1.reset();
-
-        if (options.level) {
-          loglevel(options.level);
-        }
-
-        if (process.env.__PERCY_BROWSERIFIED__) {
-          spy(Logger.prototype, 'write', function (lvl, msg) {
-            let stdio = lvl === 'info' ? 'stdout' : 'stderr';
-            helpers$1[stdio].push(sanitizeLog(msg, options));
-            return this.write.originalValue.call(this, lvl, msg);
-          });
-          spy(console, 'log');
-          spy(console, 'warn');
-          spy(console, 'error');
-        } else {
-          let {
-            Writable
-          } = await import('stream');
+      return stub;
+    } // matches ansi escape sequences
 
-          for (let stdio of ['stdout', 'stderr']) {
-            Logger[stdio] = Object.assign(new Writable(), {
-              columns: options.isTTY ? 100 : null,
-              isTTY: options.isTTY,
 
-              cursorTo() {},
+    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
 
-              clearLine() {},
-
-              _write(chunk, encoding, callback) {
-                helpers$1[stdio].push(sanitizeLog(chunk.toString(), options));
-                callback();
-              }
+    function sanitizeLog(str) {
+      return str.replace(/\r\n/g, '\n').replace(ANSI_REG, '').replace(/\n$/, '');
+    }
 
-            });
-          }
-        }
+    const helpers = {
+      async setup() {
+        utils.percy.version = '';
+        delete utils.percy.config;
+        delete utils.percy.enabled;
+        delete utils.percy.domScript;
+        delete process.env.PERCY_SERVER_ADDRESS;
+        await helpers.call('server.mock');
+        await helpers.logger.mock();
       },
 
-      reset(soft) {
-        if (soft) loglevel('info');else delete Logger.instance;
-        helpers$1.stdout.length = 0;
-        helpers$1.stderr.length = 0;
+      async teardown() {
+        var _utils$logger$log$res, _utils$logger$log;
 
-        if (console.log.reset) {
-          console.log.reset();
-          console.warn.reset();
-          console.error.reset();
-        }
-      },
+        (_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);
 
-      dump() {
-        let msgs = Array.from(Logger.instance && Logger.instance.messages || []);
-        if (!msgs.length) return;
-
-        let log = m => process.env.__PERCY_BROWSERIFIED__ ? console.log.and ? console.log.and.originalFn(m) : console.log(m) : process.stderr.write(`${m}\n`);
-
-        logger__default["default"].loglevel('debug');
-        log(logger__default["default"].format('testing', 'warn', '--- DUMPING LOGS ---'));
-        msgs.reduce((last, _ref) => {
-          let {
-            debug,
-            level,
-            message,
-            timestamp
-          } = _ref;
-          log(logger__default["default"].format(debug, level, message, timestamp - last));
-          return timestamp;
-        }, msgs[0].timestamp);
-      }
+        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;
 
-    const helpers = {
-      logger: helpers$1,
+            (_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);
+          }
+        }
 
-      async setup() {
-        utils__default["default"].percy.version = '';
-        delete utils__default["default"].percy.config;
-        delete utils__default["default"].percy.enabled;
-        delete utils__default["default"].percy.domScript;
-        delete process.env.PERCY_SERVER_ADDRESS;
-        await helpers.call('server.mock');
-        await helpers$1.mock();
+        return helpers.call('server.close');
       },
 
-      teardown: () => helpers.call('server.close'),
       getRequests: () => helpers.call('server.requests'),
       testReply: (path, reply) => helpers.call('server.reply', path, reply),
       testFailure: function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
+        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);
@@ -194,13 +87,64 @@
       : helpers.call('server.test.serialize', fn),
       // set
       mockSite: () => helpers.call('site.mock'),
-      closeSite: () => helpers.call('site.close')
+      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);
+            }
+          }
+        }
+
+      }
     };
 
     if (process.env.__PERCY_BROWSERIFIED__) {
       helpers.call = async function call(event) {
-        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-          args[_key2 - 1] = arguments[_key2];
+        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          args[_key3 - 1] = arguments[_key3];
         }
 
         let {
@@ -264,15 +208,17 @@
       helpers.call = async function call() {
         let {
           context
-        } = await import('./server.js');
+        } = await ({});
         helpers.context = helpers.context || (await context());
         return helpers.context.call(...arguments);
       };
     }
 
-    return helpers;
+    var helpers_1 = helpers;
+
+    return helpers_1;
 
-  })(PercySDKUtils.logger, PercySDKUtils);
+  })(PercySDKUtils);
 }).call(window);
 
 if (typeof define === "function" && define.amd) {

package/test/helpers.js

@@ -1,9 +1,35 @@
-import logger from '@percy/logger/test/helpers';
-import utils from '@percy/sdk-utils';
+const utils = require('@percy/sdk-utils');
 
-export const helpers = {
-  logger,
+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() {
     utils.percy.version = '';
     delete utils.percy.config;
@@ -11,10 +37,21 @@ export const helpers = {
     delete utils.percy.domScript;
     delete process.env.PERCY_SERVER_ADDRESS;
     await helpers.call('server.mock');
-    await logger.mock();
+    await helpers.logger.mock();
+  },
+
+  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');
   },
 
-  teardown: () => helpers.call('server.close'),
   getRequests: () => helpers.call('server.requests'),
   testReply: (path, reply) => helpers.call('server.reply', path, reply),
   testFailure: (...args) => helpers.call('server.test.failure', ...args),
@@ -23,7 +60,52 @@ export const helpers = {
     ? helpers.call('server.test.serialize') // get
     : helpers.call('server.test.serialize', fn), // set
   mockSite: () => helpers.call('site.mock'),
-  closeSite: () => helpers.call('site.close')
+  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?.();
+
+      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?.();
+      }
+    }
+  }
 };
 
 if (process.env.__PERCY_BROWSERIFIED__) {
@@ -77,4 +159,4 @@ if (process.env.__PERCY_BROWSERIFIED__) {
   };
 }
 
-export default helpers;
+module.exports = helpers;

package/test/server.js

@@ -1,9 +1,8 @@
-import fs from 'fs';
-import url from 'url';
-import path from 'path';
+const fs = require('fs');
+const path = require('path');
 
 // create a testing context for mocking the local percy server and a local testing site
-export async function context() {
+async function context() {
   let { createTestServer } = await import('@percy/core/test/helpers/server');
 
   let ctx = {
@@ -65,7 +64,7 @@ export async function context() {
       return next();
     });
 
-    ctx.server.websocket(ws => {
+    ctx.server.websocket('/(logger)?', ws => {
       if (!allowSocketConnections) return ws.terminate();
       ws.onmessage = ({ data }) => ctx.server.messages.push(data);
     });
@@ -109,7 +108,7 @@ export async function context() {
 }
 
 // start a testing server to control a context remotely
-export async function start(args) {
+async function start(args) {
   let { logger } = await import('@percy/logger');
   let { WebSocketServer } = await import('ws');
   let log = logger('utils:test/server');
@@ -158,7 +157,7 @@ export async function start(args) {
 }
 
 // stop any existing testing server
-export async function stop() {
+async function stop() {
   let { default: WS } = await import('ws');
 
   await new Promise(resolve => {
@@ -169,7 +168,7 @@ export async function stop() {
 }
 
 // start & stop a testing server around a command
-export async function exec(args) {
+async function exec(args) {
   let argsep = args.indexOf('--');
   if (argsep < 0) throw new Error('Must supply a command after `--`');
 
@@ -187,22 +186,20 @@ export async function exec(args) {
 }
 
 // allow invoking start/stop/exec as CLI commands
-const filename = url.fileURLToPath(import.meta.url);
-const [program, ...args] = process.argv.slice(1);
-
-if (program === filename || `${program}.js` === filename) {
+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'))) {
-    await import('child_process').then(cp => cp.fork(filename, args, {
+  } 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 {
-    await run(args.slice(1)).catch(console.error);
+    run(args.slice(1)).catch(console.error);
   }
 }
 
 // export the namespace by default
-export * as default from './server.js';
+module.exports = { context, start, stop, exec };