@atlaspack/reporter-cli 2.12.1-canary.3354

package/src/utils.js

@@ -0,0 +1,48 @@
+// @flow
+import path from 'path';
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+import termSize from 'term-size';
+import {stripAnsi} from '@atlaspack/utils';
+
+export type PadAlign = 'left' | 'right';
+let terminalSize = termSize();
+process.stdout.on('resize', function () {
+  terminalSize = termSize();
+});
+
+export function getTerminalWidth(): any {
+  return terminalSize;
+}
+
+// Pad a string with spaces on either side
+export function pad(
+  text: string,
+  length: number,
+  align: PadAlign = 'left',
+): string {
+  let pad = ' '.repeat(length - stringWidth(text));
+  if (align === 'right') {
+    return pad + text;
+  }
+
+  return text + pad;
+}
+
+export function formatFilename(
+  filename: string,
+  color: (s: string) => string = chalk.reset,
+): string {
+  let dir = path.relative(process.cwd(), path.dirname(filename));
+  return (
+    chalk.dim(dir + (dir ? path.sep : '')) + color(path.basename(filename))
+  );
+}
+
+export function countLines(message: string): number {
+  let {columns} = terminalSize;
+
+  return stripAnsi(message)
+    .split('\n')
+    .reduce((p, line) => p + Math.ceil((stringWidth(line) || 1) / columns), 0);
+}

package/test/CLIReporter.test.js

@@ -0,0 +1,257 @@
+// @flow strict-local
+
+import assert from 'assert';
+import sinon from 'sinon';
+import {PassThrough} from 'stream';
+import {_report} from '../src/CLIReporter';
+import * as render from '../src/render';
+import {_setStdio} from '../src/render';
+import {inputFS, outputFS} from '@atlaspack/test-utils';
+import {NodePackageManager} from '@atlaspack/package-manager';
+import stripAnsi from 'strip-ansi';
+import * as bundleReport from '../src/bundleReport';
+import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+
+const EMPTY_OPTIONS = {
+  cacheDir: '.atlaspack-cache',
+  atlaspackVersion: '',
+  entries: [],
+  logLevel: 'info',
+  targets: [],
+  projectRoot: '',
+  distDir: 'dist',
+  lockFile: undefined,
+  shouldAutoInstall: false,
+  shouldBuildLazily: false,
+  hmrOptions: undefined,
+  serveOptions: false,
+  mode: 'development',
+  shouldScopeHoist: false,
+  shouldOptimize: false,
+  env: {},
+  shouldDisableCache: false,
+  sourceMaps: false,
+  inputFS,
+  outputFS,
+  instanceId: 'test',
+  packageManager: new NodePackageManager(inputFS, '/'),
+  detailedReport: {
+    assetsPerBundle: 10,
+  },
+  featureFlags: DEFAULT_FEATURE_FLAGS,
+};
+
+describe('CLIReporter', () => {
+  let originalStdout;
+  let originalStderr;
+  let stdoutOutput;
+  let stderrOutput;
+
+  beforeEach(async () => {
+    // Stub these out to avoid writing noise to real stdio and to read from these
+    // otherwise only writable streams
+    originalStdout = process.stdout;
+    originalStderr = process.stderr;
+
+    stdoutOutput = '';
+    stderrOutput = '';
+
+    let mockStdout = new PassThrough();
+    mockStdout.on('data', d => (stdoutOutput += stripAnsi(d.toString())));
+    let mockStderr = new PassThrough();
+    mockStderr.on('data', d => (stderrOutput += stripAnsi(d.toString())));
+    _setStdio(mockStdout, mockStderr);
+
+    await _report(
+      {
+        type: 'buildStart',
+      },
+      EMPTY_OPTIONS,
+    );
+  });
+
+  afterEach(() => {
+    _setStdio(originalStdout, originalStderr);
+  });
+
+  it('writes log, info, success, and verbose log messages to stdout', async () => {
+    let options = {
+      ...EMPTY_OPTIONS,
+      logLevel: 'verbose',
+    };
+
+    await _report(
+      {
+        type: 'log',
+        level: 'info',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'info',
+          },
+        ],
+      },
+      options,
+    );
+    await _report({type: 'log', level: 'success', message: 'success'}, options);
+    await _report(
+      {
+        type: 'log',
+        level: 'verbose',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'verbose',
+          },
+        ],
+      },
+      options,
+    );
+
+    assert.equal(stdoutOutput, 'test: info\nsuccess\ntest: verbose\n');
+  });
+
+  it('writes errors and warnings to stderr', async () => {
+    await _report(
+      {
+        type: 'log',
+        level: 'error',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'error',
+          },
+        ],
+      },
+      EMPTY_OPTIONS,
+    );
+    await _report(
+      {
+        type: 'log',
+        level: 'warn',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'warn',
+          },
+        ],
+      },
+      EMPTY_OPTIONS,
+    );
+
+    assert.equal(stdoutOutput, '\n\n');
+    assert.equal(stderrOutput, 'test: error\ntest: warn\n');
+  });
+
+  it('prints errors nicely', async () => {
+    await _report(
+      {
+        type: 'log',
+        level: 'error',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'error',
+          },
+        ],
+      },
+      EMPTY_OPTIONS,
+    );
+    await _report(
+      {
+        type: 'log',
+        level: 'warn',
+        diagnostics: [
+          {
+            origin: 'test',
+            message: 'warn',
+          },
+        ],
+      },
+      EMPTY_OPTIONS,
+    );
+
+    assert.equal(stdoutOutput, '\n\n');
+    assert(stderrOutput.includes('test: error\n'));
+    assert(stderrOutput.includes('test: warn\n'));
+  });
+
+  it('writes buildProgress messages to stdout on the default loglevel', async () => {
+    await _report({type: 'buildProgress', phase: 'bundling'}, EMPTY_OPTIONS);
+    assert.equal(stdoutOutput, 'Bundling...\n');
+  });
+
+  it('writes buildSuccess messages to stdout on the default loglevel', async () => {
+    await _report({type: 'buildProgress', phase: 'bundling'}, EMPTY_OPTIONS);
+    assert.equal(stdoutOutput, 'Bundling...\n');
+  });
+
+  it('writes phase timings to stdout when ATLASPACK_SHOW_PHASE_TIMES is set', async () => {
+    let oldPhaseTimings = process.env['ATLASPACK_SHOW_PHASE_TIMES'];
+    const bundleReportStub = sinon.stub(bundleReport, 'default');
+    const persistSpinnerStub = sinon.stub(render, 'persistSpinner');
+
+    after(() => {
+      bundleReportStub.restore();
+      persistSpinnerStub.restore();
+      process.env['ATLASPACK_SHOW_PHASE_TIMES'] = oldPhaseTimings;
+    });
+
+    // emit a buildSuccess event to reset the timings and seen phases
+    // from the previous test
+    process.env['ATLASPACK_SHOW_PHASE_TIMES'] = undefined;
+    // $FlowFixMe
+    await _report({type: 'buildSuccess'}, EMPTY_OPTIONS);
+
+    process.env['ATLASPACK_SHOW_PHASE_TIMES'] = 'true';
+    await _report(
+      {type: 'buildProgress', phase: 'transforming', filePath: 'foo.js'},
+      EMPTY_OPTIONS,
+    );
+    await _report({type: 'buildProgress', phase: 'bundling'}, EMPTY_OPTIONS);
+    await _report(
+      // $FlowFixMe
+      {
+        type: 'buildProgress',
+        phase: 'packaging',
+        bundle: {
+          displayName: 'test',
+        },
+      },
+      EMPTY_OPTIONS,
+    );
+    // $FlowFixMe
+    await _report({type: 'buildSuccess'}, EMPTY_OPTIONS);
+    const expected =
+      /Building...\nBundling...\nPackaging & Optimizing...\nTransforming finished in [0-9]ms\nBundling finished in [0-9]ms\nPackaging & Optimizing finished in [0-9]ms/;
+
+    assert.equal(expected.test(stdoutOutput), true);
+
+    stdoutOutput = '';
+
+    await _report(
+      {type: 'buildProgress', phase: 'transforming', filePath: 'foo.js'},
+      EMPTY_OPTIONS,
+    );
+    await _report({type: 'buildProgress', phase: 'bundling'}, EMPTY_OPTIONS);
+    await _report(
+      // $FlowFixMe
+      {
+        type: 'buildProgress',
+        phase: 'packaging',
+        bundle: {
+          displayName: 'test',
+        },
+      },
+      EMPTY_OPTIONS,
+    );
+    // $FlowFixMe
+    await _report({type: 'buildSuccess'}, EMPTY_OPTIONS);
+
+    assert.equal(
+      expected.test(stdoutOutput),
+      true,
+      'STDOUT output did not match',
+    );
+  });
+});