flow like the river

BACK_BACK/node_modules/@parcel/logger/test/.babelrc

@@ -0,0 +1,8 @@
+{
+  "presets": [["@babel/preset-env", {
+    "targets": {
+      "node": "current"
+    }
+  }]],
+  "plugins": ["@babel/plugin-transform-runtime"]
+}

BACK_BACK/node_modules/@parcel/logger/test/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../.eslintrc.json",
+  "env": {
+    "mocha": true
+  }
+}

BACK_BACK/node_modules/@parcel/logger/test/logger.js

@@ -0,0 +1,123 @@
+const assert = require('assert');
+const sinon = require('sinon');
+const Logger = require('../src/Logger');
+
+describe('Logger', () => {
+  let log;
+  beforeEach(function() {
+    log = [];
+  });
+
+  const stub = instance => {
+    sinon.stub(instance, '_log').callsFake(message => {
+      log.push(message);
+    });
+  };
+
+  it('should log message on write', () => {
+    const l = new Logger.constructor({});
+    stub(l);
+
+    l.write('hello');
+    assert.equal(log[0], 'hello');
+  });
+
+  it('should track number of lines on persist false', () => {
+    const l = new Logger.constructor({});
+    stub(l);
+
+    const count = l.lines;
+    l.write('hello\nworld', false);
+    assert.equal(l.lines, count + 2);
+  });
+
+  it('should not track number of lines on persist true', () => {
+    const l = new Logger.constructor({});
+    stub(l);
+
+    const count = l.lines;
+    l.write('hello\nworld', true);
+    assert.equal(l.lines, count);
+  });
+
+  it('should respect log levels', () => {
+    const l = new Logger.constructor({logLevel: 2, color: false});
+    stub(l);
+
+    l.log('message');
+    l.persistent('message');
+    l.progress('message');
+    l.logLevel = 1;
+    l.warn('message');
+    l.logLevel = 0;
+    l.error({message: 'message', stack: 'stack'});
+
+    assert.equal(log.length, 0);
+
+    l.logLevel = 1;
+    l.error({message: 'message', stack: 'stack'});
+    assert.equal(log.length, 2);
+
+    l.logLevel = 2;
+    l.warn('message');
+    assert.equal(log.length, 3);
+
+    l.logLevel = 3;
+    l.log('message');
+    l.persistent('message');
+    l.progress('message');
+    assert.equal(log.length, 5);
+  });
+
+  it('should handle lack of color support with alternatives', () => {
+    const l = new Logger.constructor({color: false});
+    stub(l);
+
+    // clear is a no-op
+    l.lines = 4;
+    l.clear();
+    assert.equal(l.lines, 4);
+  });
+
+  it('should reset on clear', () => {
+    const l = new Logger.constructor({color: true, isTest: false});
+    stub(l);
+
+    // stub readline so we don't actually clear the test output
+    const sandbox = sinon.createSandbox();
+    sandbox.stub(require('readline'));
+
+    l.lines = 10;
+    l.clear();
+
+    assert.equal(l.lines, 0);
+    sandbox.restore();
+  });
+
+  it('should use ora for progress', () => {
+    const l = new Logger.constructor({color: false});
+
+    l.progress('message');
+
+    assert(l.spinner);
+    assert(l.spinner.text.includes('message'));
+  });
+
+  it('should use internal _log function for writes', () => {
+    const l = new Logger.constructor({color: false});
+    const sandbox = sinon.createSandbox(); // use sandbox to silence console.log
+
+    let spy;
+    try {
+      spy = sandbox.spy(l, '_log');
+      sandbox.stub(console, 'log');
+
+      l.write('hello world');
+    } finally {
+      l._log.restore();
+      sandbox.restore();
+    }
+
+    assert(spy.called);
+  });
+});

BACK_BACK/node_modules/@parcel/logger/test/mocha.opts

@@ -0,0 +1,2 @@
+--require @parcel/babel-register
+--exit

BACK_BACK/node_modules/@parcel/logger/test/prettyError.js

@@ -0,0 +1,104 @@
+const assert = require('assert');
+const prettyError = require('../src/prettyError');
+
+const message = 'Error Message!';
+const fileName = 'Test.js';
+const codeFrame = '<code>frame</code>';
+const stack =
+  'Error: Uh-oh. Something went wrong. Line 88. \n Oh no. Something else went wrong. Line 77 \n';
+
+describe('prettyError', () => {
+  it('should handle passing error as string', () => {
+    const err = prettyError(message);
+
+    assert.equal(err.message, message);
+    assert.equal(err.stack, undefined);
+  });
+
+  it('should handle passing error as object', () => {
+    const err = prettyError({message});
+
+    assert.equal(err.message, message);
+    assert.equal(err.stack, undefined);
+  });
+
+  it('should handle unknown input', () => {
+    const err = prettyError(Number.NaN);
+
+    assert(err.message.length); // non-empty error message
+    assert.equal(err.stack, undefined);
+  });
+
+  it('should prepend fileName', () => {
+    const err = prettyError({
+      message,
+      fileName
+    });
+
+    assert(err.message.startsWith(fileName));
+    assert.equal(err.stack, undefined);
+  });
+
+  it('should prepend line and column location', () => {
+    const err = prettyError({
+      message,
+      fileName,
+      loc: {
+        line: 1,
+        column: 10
+      }
+    });
+
+    assert(err.message.startsWith(`${fileName}:1:10`));
+    assert.equal(err.stack, undefined);
+  });
+
+  it('should support providing a codeFrame as stack', () => {
+    const err = prettyError({
+      message,
+      stack,
+      codeFrame: codeFrame
+    });
+
+    assert.equal(err.message, message);
+    assert.equal(err.stack, codeFrame);
+  });
+
+  it('should support highlightedCodeFrame when opts.color is true', () => {
+    let err = prettyError(
+      {
+        message,
+        stack,
+        codeFrame: '<not>a code frame</not>',
+        highlightedCodeFrame: codeFrame
+      },
+      {color: true}
+    );
+
+    assert.equal(err.message, message);
+    assert.equal(err.stack, codeFrame);
+
+    err = prettyError(
+      {
+        message,
+        stack,
+        codeFrame: codeFrame,
+        highlightedCodeFrame: '<not>a code frame</not>'
+      },
+      {color: false}
+    );
+
+    assert.equal(err.message, message);
+    assert.equal(err.stack, codeFrame);
+  });
+
+  it('should support stack', () => {
+    const err = prettyError({
+      message,
+      stack
+    });
+
+    assert.equal(err.message, message);
+    assert(err.stack.includes('Line'));
+  });
+});