@percy/logger 1.0.0-beta.7 → 1.0.0-beta.73

package/test/helpers.js

@@ -0,0 +1,121 @@
+const logger = require('@percy/logger');
+const { ANSI_REG } = require('@percy/logger/dist/util');
+const { Logger } = logger;
+
+const ELAPSED_REG = /\s\S*?\(\d+ms\)\S*/;
+const NEWLINE_REG = /\r\n/g;
+const LASTLINE_REG = /\n$/;
+
+function sanitizeLog(str, { ansi, elapsed } = {}) {
+  // 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 TestIO(data, options) {
+  if (!process.env.__PERCY_BROWSERIFIED__) {
+    let { Writable } = require('stream');
+
+    return Object.assign(new Writable(), {
+      isTTY: options && options.isTTY,
+      cursorTo() {},
+      clearLine() {},
+
+      _write(chunk, encoding, callback) {
+        data.push(sanitizeLog(chunk.toString(), options));
+        callback();
+      }
+    });
+  }
+}
+
+function spy(object, method, func) {
+  if (object[method].reset) {
+    object[method].reset();
+    return object[method];
+  }
+
+  let spy = Object.assign(function spy(...args) {
+    spy.calls.push(args);
+    if (func) return func.apply(this, args);
+  }, {
+    restore: () => (object[method] = spy.originalValue),
+    reset: () => (spy.calls.length = 0),
+    originalValue: object[method],
+    calls: []
+  });
+
+  object[method] = spy;
+  return spy;
+}
+
+const helpers = {
+  constructor: Logger,
+  loglevel: logger.loglevel,
+  stdout: [],
+  stderr: [],
+
+  get messages() {
+    return Logger.instance &&
+      Logger.instance.messages;
+  },
+
+  mock(options) {
+    helpers.reset();
+    helpers.options = options;
+
+    if (!process.env.__PERCY_BROWSERIFIED__) {
+      Logger.stdout = TestIO(helpers.stdout, options);
+      Logger.stderr = TestIO(helpers.stderr, options);
+    } else {
+      spy(Logger.prototype, 'write', function(lvl, msg) {
+        let stdio = lvl === 'info' ? 'stdout' : 'stderr';
+        helpers[stdio].push(sanitizeLog(msg, helpers.options));
+        return this.write.originalValue.call(this, lvl, msg);
+      });
+
+      spy(console, 'log');
+      spy(console, 'warn');
+      spy(console, 'error');
+    }
+  },
+
+  reset(soft) {
+    if (soft) Logger.instance.loglevel('info');
+    else delete Logger.instance;
+
+    helpers.stdout.length = 0;
+    helpers.stderr.length = 0;
+
+    if (console.log.reset) {
+      console.log.reset();
+      console.warn.reset();
+      console.error.reset();
+    }
+  },
+
+  dump() {
+    if (!helpers.messages || !helpers.messages.size) return;
+    if (console.log.and) console.log.and.callThrough();
+
+    let write = m => process.env.__PERCY_BROWSERIFIED__
+      ? console.log(m) : process.stderr.write(`${m}\n`);
+    let logs = Array.from(helpers.messages);
+
+    logger.loglevel('debug');
+
+    write(logger.format('testing', 'warn', '--- DUMPING LOGS ---'));
+
+    logs.reduce((lastlog, { debug, level, message, timestamp }) => {
+      write(logger.format(debug, level, message, timestamp - lastlog));
+      return timestamp;
+    }, logs[0].timestamp);
+  }
+};
+
+module.exports = helpers;

package/index.js

@@ -1,99 +0,0 @@
-const os = require('os');
-const path = require('path');
-const { createLogger, transports, format } = require('winston');
-const colors = require('colors/safe');
-
-// A very basic url regexp only used for highlighting URLs blue in the CLI.
-const URL_REGEXP = /\b(https?:\/\/)[\w-]+(\.[\w-]+)*(:\d+)?(\/\S*)?\b/gi;
-const TEMP_DIR = path.join(os.tmpdir(), 'percy');
-
-// Custom logging formatter to color log levels, insert a megenta label, and
-// highlight URLs logged to the transport
-function formatter({ label, level, message }) {
-  label = colors.magenta(label);
-
-  if (level === 'error') {
-    message = colors.red(message);
-  } else if (level === 'warn') {
-    message = colors.yellow(message);
-  } else if (level === 'info') {
-    // highlight urls blue
-    message = message.replace(URL_REGEXP, colors.blue('$&'));
-  }
-
-  return `[${label}] ${message}`;
-}
-
-// Global logger
-const logger = createLogger({
-  transports: [
-    // console transport logs errors by default
-    new transports.Console({
-      level: 'error',
-      stderrLevels: ['error'],
-      format: format.combine(
-        format.label({ label: 'percy' }),
-        format.printf(formatter)
-      )
-    }),
-    // file transport logs everything
-    new transports.File({
-      level: 'debug',
-      filename: path.join(TEMP_DIR, `percy.${Date.now()}.log`),
-      format: format.combine(
-        format.timestamp(),
-        format.json()
-      )
-    })
-  ]
-});
-
-// Attach the formatter so external logs can utilize it
-logger.formatter = message => formatter(
-  typeof message === 'string' ? { label: 'percy', message } : message
-);
-
-// Method to change the global logger's console log level. The second argument
-// can be used to set the appropriate level based on boolean flags and fallback
-// to the provided log level.
-logger.loglevel = function loglevel(level, flags = {}) {
-  if (!level) return this.transports[0].level;
-
-  if (flags.verbose) level = 'debug';
-  else if (flags.quiet) level = 'warn';
-  else if (flags.silent) level = 'silent';
-
-  this.transports[0].level = level;
-};
-
-// Patch the error method to handle error objects. Winston accepts objects with
-// messages and meta as an argument but will fail to log real error instances.
-logger.error = function(message) {
-  // libraries may also throw errors which are not technically Error instances
-  if (typeof message === 'object') {
-    // get the stack trace for debug (no ternary to always fallback to string)
-    message = (this.loglevel() === 'debug' && message.stack) || message.toString();
-  }
-
-  // return super.error(message)
-  return this.constructor.prototype.error.call(this, message);
-};
-
-// Patch the query method to return a promise, query the file transport only,
-// and allow filtering logs with a filter function.
-logger.query = function(options = {}) {
-  return new Promise((resolve, reject) => {
-    // the query method mutates options to normalize and set defaults, so the
-    // same is done here to set more desirable defaults
-    options.limit = options.limit || Infinity;
-    options.order = options.order || 'asc';
-
-    this.transports[1].query(options, (err, logs) => {
-      if (err) return reject(err);
-      if (options.filter) logs = logs.filter(options.filter);
-      resolve(logs);
-    });
-  });
-};
-
-module.exports = logger;

package/test/.eslintrc

@@ -1,2 +0,0 @@
-env:
-  mocha: true

package/test/helper.js

@@ -1,52 +0,0 @@
-import stripAnsi from 'strip-ansi';
-
-const og = {
-  out: process.stdout.write,
-  err: process.stderr.write
-};
-
-function format(chunk, { ansi = false } = {}) {
-  // strip ansi and normalize line endings
-  return (ansi ? chunk : stripAnsi(chunk)).replace('\r\n', '\n');
-}
-
-function tryFinally(fn, cb) {
-  let done = (r, e) => {
-    if ((cb(), e)) throw e;
-    return r;
-  };
-
-  let r, e;
-  try { r = fn(); } catch (err) { e = err; }
-
-  if (typeof r?.then === 'function') {
-    return r.then(done, e => done(null, e));
-  } else {
-    return done(r, e);
-  }
-}
-
-const stdio = {
-  1: [],
-  2: [],
-
-  capture(fn, options) {
-    stdio.flush();
-    process.stdout.write = chunk => stdio[1].push(format(chunk, options));
-    process.stderr.write = chunk => stdio[2].push(format(chunk, options));
-    return fn ? tryFinally(fn, stdio.restore) : null;
-  },
-
-  restore() {
-    process.stdout.write = og.out;
-    process.stderr.write = og.err;
-  },
-
-  flush() {
-    let output = [null, stdio[1], stdio[2]];
-    stdio[1] = []; stdio[2] = [];
-    return output;
-  }
-};
-
-export default stdio;

package/test/index.test.js

@@ -1,134 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import expect from 'expect';
-import colors from 'colors/safe';
-import stdio from './helper';
-import log from '..';
-
-describe('logger', () => {
-  const label = colors.magenta('percy');
-
-  beforeEach(() => {
-    let { dirname, filename } = log.transports[1];
-    let logfile = path.join(dirname, filename);
-    fs.writeFileSync(logfile, '');
-    log.loglevel('debug');
-  });
-
-  afterEach(() => {
-    log.loglevel('error');
-  });
-
-  it('formats the message with a percy label', () => {
-    stdio.capture(() => log.debug('test'), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] test\n`]);
-  });
-
-  it('formats errors red', () => {
-    stdio.capture(() => log.error('error'), { ansi: true });
-    expect(stdio[2]).toEqual([`[${label}] ${colors.red('error')}\n`]);
-  });
-
-  it('formats warnings yellow', () => {
-    stdio.capture(() => log.warn('warning'), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] ${colors.yellow('warning')}\n`]);
-  });
-
-  it('formats info URLs blue', () => {
-    let url = 'https://localhost:3000/foobar/baz.png';
-    stdio.capture(() => log.info(`url = ${url}`), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] url = ${colors.blue(url)}\n`]);
-  });
-
-  describe('#formatter()', () => {
-    it('returns a string formatted as a percy log', () => {
-      expect(log.formatter('testing')).toEqual(`[${label}] testing`);
-    });
-
-    it('accepts a logger meta object', () => {
-      expect(log.formatter({ label: 'test', message: 'foobar' }))
-        .toEqual(`[${colors.magenta('test')}] foobar`);
-    });
-  });
-
-  describe('#loglevel()', () => {
-    it('sets the first transport log level', () => {
-      expect(log.transports[0].level).toBe('debug');
-      log.loglevel('info');
-      expect(log.transports[0].level).toBe('info');
-    });
-
-    it('returns the first transport log level without args', () => {
-      expect(log.loglevel()).toBe(log.transports[0].level);
-    });
-
-    it('sets the log level to debug with a verbose flag', () => {
-      log.loglevel('info', { verbose: true });
-      expect(log.loglevel()).toBe('debug');
-    });
-
-    it('sets the log level to warn with a quiet flag', () => {
-      log.loglevel('info', { quiet: true });
-      expect(log.loglevel()).toBe('warn');
-    });
-
-    it('sets the log level to silent with a silent flag', () => {
-      log.loglevel('info', { silent: true });
-      expect(log.loglevel()).toBe('silent');
-    });
-  });
-
-  describe('#error()', () => {
-    it('is patched to log error instance strings', () => {
-      log.loglevel('error');
-      stdio.capture(() => log.error(new Error('message')));
-      expect(stdio[2]).toEqual(['[percy] Error: message\n']);
-    });
-
-    it('logs the error instance stack trace in debug', () => {
-      let err = new Error('message');
-      stdio.capture(() => log.error(err));
-      expect(stdio[2]).toEqual([`[percy] ${err.stack}\n`]);
-    });
-
-    it('falls back if there is no error instance stack in debug', () => {
-      let err = { toString: () => 'error' };
-      stdio.capture(() => log.error(err));
-      expect(stdio[2]).toEqual(['[percy] error\n']);
-    });
-  });
-
-  describe('#query()', () => {
-    beforeEach(() => {
-      stdio.capture(() => {
-        log.info('foo', { foo: true });
-        log.info('bar', { bar: true });
-      });
-    });
-
-    it('is promisified', async () => {
-      await expect(log.query()).resolves.toEqual([
-        expect.objectContaining({ message: 'foo', foo: true }),
-        expect.objectContaining({ message: 'bar', bar: true })
-      ]);
-
-      await expect(log.query({
-        get level() { throw new Error('test'); }
-      })).rejects.toThrow('test');
-    });
-
-    it('can filter logs', async () => {
-      await expect(log.query({
-        filter: log => log.foo
-      })).resolves.toEqual([
-        expect.objectContaining({ message: 'foo', foo: true })
-      ]);
-
-      await expect(log.query({
-        filter: log => log.bar
-      })).resolves.toEqual([
-        expect.objectContaining({ message: 'bar', bar: true })
-      ]);
-    });
-  });
-});