Move testing to ava (#182)

test/_fixture.js

@@ -0,0 +1,4 @@
+'use strict';
+const chalk = require('..');
+
+console.log(chalk.hex('#ff6159')('test'));

test/_supports-color.js

@@ -0,0 +1,13 @@
+'use strict';
+const resolveFrom = require('resolve-from');
+
+module.exports = dir => {
+	require.cache[resolveFrom(dir, 'supports-color')] = {
+		exports: {
+			level: 3,
+			hasBasic: true,
+			has256: true,
+			has16m: true
+		}
+	};
+};

test/chalk.js

@@ -0,0 +1,96 @@
+import test from 'ava';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+const m = require('..');
+
+console.log('TERM:', process.env.TERM || '[none]');
+console.log('platform:', process.platform || '[unknown]');
+
+test('don\'t add any styling when called as the base function', t => {
+	t.is(m('foo'), 'foo');
+});
+
+test('style string', t => {
+	t.is(m.underline('foo'), '\u001B[4mfoo\u001B[24m');
+	t.is(m.red('foo'), '\u001B[31mfoo\u001B[39m');
+	t.is(m.bgRed('foo'), '\u001B[41mfoo\u001B[49m');
+});
+
+test('support applying multiple styles at once', t => {
+	t.is(m.red.bgGreen.underline('foo'), '\u001B[31m\u001B[42m\u001B[4mfoo\u001B[24m\u001B[49m\u001B[39m');
+	t.is(m.underline.red.bgGreen('foo'), '\u001B[4m\u001B[31m\u001B[42mfoo\u001B[49m\u001B[39m\u001B[24m');
+});
+
+test('support nesting styles', t => {
+	t.is(
+		m.red('foo' + m.underline.bgBlue('bar') + '!'),
+		'\u001B[31mfoo\u001B[4m\u001B[44mbar\u001B[49m\u001B[24m!\u001B[39m'
+	);
+});
+
+test('support nesting styles of the same type (color, underline, bg)', t => {
+	t.is(
+		m.red('a' + m.yellow('b' + m.green('c') + 'b') + 'c'),
+		'\u001B[31ma\u001B[33mb\u001B[32mc\u001B[33mb\u001B[31mc\u001B[39m'
+	);
+});
+
+test('reset all styles with `.reset()`', t => {
+	t.is(m.reset(m.red.bgGreen.underline('foo') + 'foo'), '\u001B[0m\u001B[31m\u001B[42m\u001B[4mfoo\u001B[24m\u001B[49m\u001B[39mfoo\u001B[0m');
+});
+
+test('support caching multiple styles', t => {
+	const red = m.red;
+	const green = m.green;
+	const redBold = red.bold;
+	const greenBold = green.bold;
+
+	t.not(red('foo'), green('foo'));
+	t.not(redBold('bar'), greenBold('bar'));
+	t.not(green('baz'), greenBold('baz'));
+});
+
+test('alias gray to grey', t => {
+	t.is(m.grey('foo'), '\u001B[90mfoo\u001B[39m');
+});
+
+test('support variable number of arguments', t => {
+	t.is(m.red('foo', 'bar'), '\u001B[31mfoo bar\u001B[39m');
+});
+
+test('support falsy values', t => {
+	t.is(m.red(0), '\u001B[31m0\u001B[39m');
+});
+
+test('don\'t output escape codes if the input is empty', t => {
+	t.is(m.red(), '');
+	t.is(m.red.blue.black(), '');
+});
+
+test('keep Function.prototype methods', t => {
+	t.is(m.grey.apply(null, ['foo']), '\u001B[90mfoo\u001B[39m');
+	t.is(m.reset(m.red.bgGreen.underline.bind(null)('foo') + 'foo'), '\u001B[0m\u001B[31m\u001B[42m\u001B[4mfoo\u001B[24m\u001B[49m\u001B[39mfoo\u001B[0m');
+	t.is(m.red.blue.black.call(null), '');
+});
+
+test('line breaks should open and close colors', t => {
+	t.is(m.grey('hello\nworld'), '\u001B[90mhello\u001B[39m\n\u001B[90mworld\u001B[39m');
+});
+
+test('properly convert RGB to 16 colors on basic color terminals', t => {
+	t.is(new m.constructor({level: 1}).hex('#FF0000')('hello'), '\u001B[91mhello\u001B[39m');
+	t.is(new m.constructor({level: 1}).bgHex('#FF0000')('hello'), '\u001B[101mhello\u001B[49m');
+});
+
+test('properly convert RGB to 256 colors on basic color terminals', t => {
+	t.is(new m.constructor({level: 2}).hex('#FF0000')('hello'), '\u001B[38;5;196mhello\u001B[39m');
+	t.is(new m.constructor({level: 2}).bgHex('#FF0000')('hello'), '\u001B[48;5;196mhello\u001B[49m');
+	t.is(new m.constructor({level: 3}).bgHex('#FF0000')('hello'), '\u001B[48;2;255;0;0mhello\u001B[49m');
+});
+
+test('don\'t emit RGB codes if level is 0', t => {
+	t.is(new m.constructor({level: 0}).hex('#FF0000')('hello'), 'hello');
+	t.is(new m.constructor({level: 0}).bgHex('#FF0000')('hello'), 'hello');
+});

test/constructor.js

@@ -0,0 +1,22 @@
+import test from 'ava';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+const m = require('..');
+
+test('create an isolated context where colors can be disabled (by level)', t => {
+	const ctx = new m.constructor({level: 0, enabled: true});
+	t.is(ctx.red('foo'), 'foo');
+	t.is(m.red('foo'), '\u001B[31mfoo\u001B[39m');
+	ctx.level = 2;
+	t.is(ctx.red('foo'), '\u001B[31mfoo\u001B[39m');
+});
+
+test('create an isolated context where colors can be disabled (by enabled flag)', t => {
+	const ctx = new m.constructor({enabled: false});
+	t.is(ctx.red('foo'), 'foo');
+	t.is(m.red('foo'), '\u001B[31mfoo\u001B[39m');
+	ctx.enabled = true;
+	t.is(ctx.red('foo'), '\u001B[31mfoo\u001B[39m');
+});

test/enabled.js

@@ -0,0 +1,35 @@
+import test from 'ava';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+const m = require('..');
+
+test('don\'t output colors when manually disabled', t => {
+	m.enabled = false;
+	t.is(m.red('foo'), 'foo');
+	m.enabled = true;
+});
+
+test('enable/disable colors based on overall chalk enabled property, not individual instances', t => {
+	m.enabled = false;
+	const red = m.red;
+	t.false(red.enabled);
+	m.enabled = true;
+	t.true(red.enabled);
+	m.enabled = true;
+});
+
+test('propagate enable/disable changes from child colors', t => {
+	m.enabled = false;
+	const red = m.red;
+	t.false(red.enabled);
+	t.false(m.enabled);
+	red.enabled = true;
+	t.true(red.enabled);
+	t.true(m.enabled);
+	m.enabled = false;
+	t.false(red.enabled);
+	t.false(m.enabled);
+	m.enabled = true;
+});

test/level.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import test from 'ava';
+import execa from 'execa';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+const m = require('..');
+
+test('don\'t output colors when manually disabled', t => {
+	const oldLevel = m.level;
+	m.level = 0;
+	t.is(m.red('foo'), 'foo');
+	m.level = oldLevel;
+});
+
+test('enable/disable colors based on overall chalk enabled property, not individual instances', t => {
+	const oldLevel = m.level;
+	m.level = 1;
+	const red = m.red;
+	t.is(red.level, 1);
+	m.level = 0;
+	t.is(red.level, m.level);
+	m.level = oldLevel;
+});
+
+test('propagate enable/disable changes from child colors', t => {
+	const oldLevel = m.level;
+	m.level = 1;
+	const red = m.red;
+	t.is(red.level, 1);
+	t.is(m.level, 1);
+	red.level = 0;
+	t.is(red.level, 0);
+	t.is(m.level, 0);
+	m.level = 1;
+	t.is(red.level, 1);
+	t.is(m.level, 1);
+	m.level = oldLevel;
+});
+
+test.failing('disable colors if they are not supported', async t => {
+	t.is(await execa.stdout('node', [path.join(__dirname, '_fixture')]), 'test');
+});

test/template-literal.js

@@ -0,0 +1,95 @@
+import test from 'ava';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+const m = require('..');
+
+test('return an empty string for an empty literal', t => {
+	const ctx = m.constructor();
+	t.is(ctx``, '');
+});
+
+test('return a regular string for a literal with no templates', t => {
+	const ctx = m.constructor({level: 0});
+	t.is(ctx`hello`, 'hello');
+});
+
+test('correctly perform template parsing', t => {
+	const ctx = m.constructor({level: 0});
+	t.is(ctx`{bold Hello, {cyan World!} This is a} test. {green Woo!}`,
+		ctx.bold('Hello,', ctx.cyan('World!'), 'This is a') + ' test. ' + ctx.green('Woo!'));
+});
+
+test('correctly perform template substitutions', t => {
+	const ctx = m.constructor({level: 0});
+	const name = 'Sindre';
+	const exclamation = 'Neat';
+	t.is(ctx`{bold Hello, {cyan.inverse ${name}!} This is a} test. {green ${exclamation}!}`,
+		ctx.bold('Hello,', ctx.cyan.inverse(name + '!'), 'This is a') + ' test. ' + ctx.green(exclamation + '!'));
+});
+
+test('correctly parse and evaluate color-convert functions', t => {
+	const ctx = m.constructor({level: 3});
+	t.is(ctx`{bold.rgb(144,10,178).inverse Hello, {~inverse there!}}`,
+		'\u001B[0m\u001B[1m\u001B[38;2;144;10;178m\u001B[7mHello, ' +
+		'\u001B[27m\u001B[39m\u001B[22m\u001B[0m\u001B[0m\u001B[1m' +
+		'\u001B[38;2;144;10;178mthere!\u001B[39m\u001B[22m\u001B[0m');
+
+	t.is(ctx`{bold.bgRgb(144,10,178).inverse Hello, {~inverse there!}}`,
+		'\u001B[0m\u001B[1m\u001B[48;2;144;10;178m\u001B[7mHello, ' +
+		'\u001B[27m\u001B[49m\u001B[22m\u001B[0m\u001B[0m\u001B[1m' +
+		'\u001B[48;2;144;10;178mthere!\u001B[49m\u001B[22m\u001B[0m');
+});
+
+test('properly handle escapes', t => {
+	const ctx = m.constructor({level: 3});
+	t.is(ctx`{bold hello \{in brackets\}}`,
+		'\u001B[0m\u001B[1mhello {in brackets}\u001B[22m\u001B[0m');
+});
+
+test('throw if there is an unclosed block', t => {
+	const ctx = m.constructor({level: 3});
+	try {
+		console.log(ctx`{bold this shouldn't appear ever\}`);
+		t.fail();
+	} catch (err) {
+		t.is(err.message, 'Template literal has an unclosed block');
+	}
+});
+
+test('throw if there is an invalid style', t => {
+	const ctx = m.constructor({level: 3});
+	try {
+		console.log(ctx`{abadstylethatdoesntexist this shouldn't appear ever}`);
+		t.fail();
+	} catch (err) {
+		t.is(err.message, 'Invalid Chalk style: abadstylethatdoesntexist');
+	}
+});
+
+test('properly style multiline color blocks', t => {
+	const ctx = m.constructor({level: 3});
+	t.is(
+		ctx`{bold
+			Hello! This is a
+			${'multiline'} block!
+			:)
+		} {underline
+			I hope you enjoy
+		}`,
+		'\u001B[0m\u001B[1m\u001B[22m\u001B[0m\n' +
+		'\u001B[0m\u001B[1m\t\t\t\tHello! This is a\u001B[22m\u001B[0m\n' +
+		'\u001B[0m\u001B[1m\t\t\t\tmultiline block!\u001B[22m\u001B[0m\n' +
+		'\u001B[0m\u001B[1m\t\t\t\t:)\u001B[22m\u001B[0m\n' +
+		'\u001B[0m\u001B[1m\t\t\t\u001B[22m\u001B[0m\u001B[0m \u001B[0m\u001B[0m\u001B[4m\u001B[24m\u001B[0m\n' +
+		'\u001B[0m\u001B[4m\t\t\t\tI hope you enjoy\u001B[24m\u001B[0m\n' +
+		'\u001B[0m\u001B[4m\t\t\t\u001B[24m\u001B[0m'
+	);
+});
+
+test('escape interpolated values', t => {
+	const ctx = m.constructor({level: 0});
+	t.is(ctx`Hello {bold hi}`, 'Hello hi');
+	t.is(ctx`Hello ${'{bold hi}'}`, 'Hello {bold hi}');
+});

test/windows.js

@@ -0,0 +1,63 @@
+import test from 'ava';
+import importFresh from 'import-fresh';
+import resolveFrom from 'resolve-from';
+
+// Spoof supports-color
+require('./_supports-color')(__dirname);
+
+let originalEnv;
+let originalPlatform;
+
+test.before(() => {
+	originalEnv = process.env;
+	originalPlatform = process.platform;
+});
+
+test.after(() => {
+	process.env = originalEnv;
+	Object.defineProperty(process, 'platform', {value: originalPlatform});
+});
+
+test.beforeEach(() => {
+	process.env = {};
+	Object.defineProperty(process, 'platform', {value: 'win32'});
+	// Since chalk internally modifies `ansiStyles.blue.open`, `ansi-styles` needs
+	// to be removed from the require cache for `require-uncached` to work
+	delete require.cache[resolveFrom(__dirname, 'ansi-styles')];
+});
+
+test('detect a simple term if TERM isn\'t set', t => {
+	delete process.env.TERM;
+	const m = importFresh('..');
+	t.is(m.blue('foo'), '\u001B[94mfoo\u001B[39m');
+});
+
+test('replace blue foreground color in cmd.exe', t => {
+	process.env.TERM = 'dumb';
+	const m = importFresh('..');
+	t.is(m.blue('foo'), '\u001B[94mfoo\u001B[39m');
+});
+
+test('don\'t replace blue foreground color in xterm based terminals', t => {
+	process.env.TERM = 'xterm-256color';
+	const m = importFresh('..');
+	t.is(m.blue('foo'), '\u001B[34mfoo\u001B[39m');
+});
+
+test('don\'t apply dimmed styling on gray strings, see https://github.com/chalk/chalk/issues/58', t => {
+	process.env.TERM = 'dumb';
+	const m = importFresh('..');
+	t.is(m.gray.dim('foo'), '\u001B[90mfoo\u001B[22m\u001B[39m');
+});
+
+test('apply dimmed styling on xterm compatible terminals', t => {
+	process.env.TERM = 'xterm';
+	const m = importFresh('..');
+	t.is(m.gray.dim('foo'), '\u001B[90m\u001B[2mfoo\u001B[22m\u001B[39m');
+});
+
+test('apply dimmed styling on strings of other colors', t => {
+	process.env.TERM = 'dumb';
+	const m = importFresh('..');
+	t.is(m.blue.dim('foo'), '\u001B[94m\u001B[2mfoo\u001B[22m\u001B[39m');
+});