X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs-website;a=blobdiff_plain;f=node_modules%2Fgrunt-legacy-log%2Ftest%2Findex.js;fp=node_modules%2Fgrunt-legacy-log%2Ftest%2Findex.js;h=878c270481ee29f21d1e5f597702dc57ca7229ad;hp=0000000000000000000000000000000000000000;hb=a2bd1bf0c2c1f1a17d188f4dc0726a45494cefae;hpb=57c063afa3f66b07c4bbddc2d6129a96d90f0aad

diff --git a/node_modules/grunt-legacy-log/test/index.js b/node_modules/grunt-legacy-log/test/index.js
new file mode 100644
index 000000000..878c27048
--- /dev/null
+++ b/node_modules/grunt-legacy-log/test/index.js
@@ -0,0 +1,519 @@
+'use strict';
+
+var legacyLog = require('../');
+var Log = legacyLog.Log;
+
+// Helper for testing stdout
+var hooker = require('hooker');
+function stdoutEqual(test, callback, expected) {
+  var actual = '';
+  // Hook process.stdout.write
+  hooker.hook(process.stdout, 'write', {
+    // This gets executed before the original process.stdout.write.
+    pre: function(result) {
+      // Concatenate uncolored result onto actual.
+      actual += result;
+      // Prevent the original process.stdout.write from executing.
+      return hooker.preempt();
+    },
+  });
+  // Execute the logging code to be tested.
+  callback();
+  // Restore process.stdout.write to its original value.
+  stdoutUnmute();
+  // Actually test the actually-logged stdout string to the expected value.
+  // test.equal(legacyLog.uncolor(actual), expected);
+  test.equal(actual, expected);
+}
+
+// Outright mute stdout.
+function stdoutMute() {
+  hooker.hook(process.stdout, 'write', {
+    pre: function() {
+      return hooker.preempt();
+    },
+  });
+}
+
+// Unmute stdout.
+function stdoutUnmute() {
+  hooker.unhook(process.stdout, 'write');
+}
+
+// Helper function: repeat('a', 3) -> 'aaa', repeat('a', 3, '-') -> 'a-a-a'
+function repeat(str, n, separator) {
+  var result = str;
+  for (var i = 1; i < n; i++) {
+    result += (separator || '') + str;
+  }
+  return result;
+}
+
+var fooBuffer = new Buffer('foo');
+
+exports['Log instance'] = {
+  setUp: function(done) {
+    this.grunt = {fail: {errorcount: 0}};
+    done();
+  },
+  'write': function(test) {
+    test.expect(4);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.write(''); }, '');
+    stdoutEqual(test, function() { log.write('foo'); }, 'foo');
+    stdoutEqual(test, function() { log.write('%s', 'foo'); }, 'foo');
+    stdoutEqual(test, function() { log.write(fooBuffer); }, 'foo');
+
+    test.done();
+  },
+  'writeln': function(test) {
+    test.expect(4);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.writeln(); }, '\n');
+    stdoutEqual(test, function() { log.writeln('foo'); }, 'foo\n');
+    stdoutEqual(test, function() { log.writeln('%s', 'foo'); }, 'foo\n');
+    stdoutEqual(test, function() { log.writeln(fooBuffer); }, 'foo\n');
+
+    test.done();
+  },
+  'warn': function(test) {
+    test.expect(5);
+    var log = new Log({grunt: this.grunt});
+
+    stdoutEqual(test, function() { log.warn(); }, 'ERROR'.red + '\n');
+    stdoutEqual(test, function() { log.warn('foo'); }, '>> '.red + 'foo\n');
+    stdoutEqual(test, function() { log.warn('%s', 'foo'); }, '>> '.red + 'foo\n');
+    stdoutEqual(test, function() { log.warn(fooBuffer); }, '>> '.red + 'foo\n');
+    test.equal(this.grunt.fail.errorcount, 0);
+
+    test.done();
+  },
+  'error': function(test) {
+    test.expect(5);
+    var log = new Log({grunt: this.grunt});
+
+    stdoutEqual(test, function() { log.error(); }, 'ERROR'.red + '\n');
+    stdoutEqual(test, function() { log.error('foo'); }, '>> '.red + 'foo\n');
+    stdoutEqual(test, function() { log.error('%s', 'foo'); }, '>> '.red + 'foo\n');
+    stdoutEqual(test, function() { log.error(fooBuffer); }, '>> '.red + 'foo\n');
+    test.equal(this.grunt.fail.errorcount, 4);
+
+    test.done();
+  },
+  'ok': function(test) {
+    test.expect(4);
+    var log = new Log({grunt: this.grunt});
+
+    stdoutEqual(test, function() { log.ok(); }, 'OK'.green + '\n');
+    stdoutEqual(test, function() { log.ok('foo'); }, '>> '.green + 'foo\n');
+    stdoutEqual(test, function() { log.ok('%s', 'foo'); }, '>> '.green + 'foo\n');
+    stdoutEqual(test, function() { log.ok(fooBuffer); }, '>> '.green + 'foo\n');
+
+    test.done();
+  },
+  'errorlns': function(test) {
+    test.expect(2);
+    var log = new Log({grunt: this.grunt});
+
+    stdoutEqual(test, function() {
+      log.errorlns(repeat('foo', 30, ' '));
+    }, '>> '.red + repeat('foo', 19, ' ') +
+      '\n>> '.red + repeat('foo', 11, ' ') + '\n');
+    test.equal(this.grunt.fail.errorcount, 1);
+
+    test.done();
+  },
+  'oklns': function(test) {
+    test.expect(1);
+    var log = new Log();
+
+    stdoutEqual(test, function() {
+      log.oklns(repeat('foo', 30, ' '));
+    }, '>> '.green + repeat('foo', 19, ' ') +
+      '\n>> '.green + repeat('foo', 11, ' ') + '\n');
+
+    test.done();
+  },
+  'success': function(test) {
+    test.expect(4);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.success(); }, ''.green + '\n');
+    stdoutEqual(test, function() { log.success('foo'); }, 'foo'.green + '\n');
+    stdoutEqual(test, function() { log.success('%s', 'foo'); }, 'foo'.green + '\n');
+    stdoutEqual(test, function() { log.success(fooBuffer); }, 'foo'.green + '\n');
+
+    test.done();
+  },
+  'fail': function(test) {
+    test.expect(4);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.fail(); }, ''.red + '\n');
+    stdoutEqual(test, function() { log.fail('foo'); }, 'foo'.red + '\n');
+    stdoutEqual(test, function() { log.fail('%s', 'foo'); }, 'foo'.red + '\n');
+    stdoutEqual(test, function() { log.fail(fooBuffer); }, 'foo'.red + '\n');
+
+    test.done();
+  },
+  'header': function(test) {
+    test.expect(5);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.header(); }, ''.underline + '\n');
+    stdoutEqual(test, function() { log.header(); }, '\n' + ''.underline + '\n');
+    stdoutEqual(test, function() { log.header('foo'); }, '\n' + 'foo'.underline + '\n');
+    stdoutEqual(test, function() { log.header('%s', 'foo'); }, '\n' + 'foo'.underline + '\n');
+    stdoutEqual(test, function() { log.header(fooBuffer); }, '\n' + 'foo'.underline + '\n');
+
+    test.done();
+  },
+  'subhead': function(test) {
+    test.expect(5);
+    var log = new Log();
+
+    stdoutEqual(test, function() { log.subhead(); }, ''.bold + '\n');
+    stdoutEqual(test, function() { log.subhead(); }, '\n' + ''.bold + '\n');
+    stdoutEqual(test, function() { log.subhead('foo'); }, '\n' + 'foo'.bold + '\n');
+    stdoutEqual(test, function() { log.subhead('%s', 'foo'); }, '\n' + 'foo'.bold + '\n');
+    stdoutEqual(test, function() { log.subhead(fooBuffer); }, '\n' + 'foo'.bold + '\n');
+
+    test.done();
+  },
+  'writetableln': function(test) {
+    test.expect(1);
+    var log = new Log();
+
+    stdoutEqual(test, function() {
+      log.writetableln([10], [repeat('foo', 10)]);
+    }, 'foofoofoof\noofoofoofo\nofoofoofoo\n');
+
+    test.done();
+  },
+  'writelns': function(test) {
+    test.expect(1);
+    var log = new Log();
+
+    stdoutEqual(test, function() {
+      log.writelns(repeat('foo', 30, ' '));
+    }, repeat('foo', 20, ' ') + '\n' +
+      repeat('foo', 10, ' ') + '\n');
+
+    test.done();
+  },
+  'writeflags': function(test) {
+    test.expect(3);
+    var log = new Log();
+
+    stdoutEqual(test, function() {
+      log.writeflags(['a', 'b']);
+    }, 'Flags: ' + 'a'.cyan + ', ' + 'b'.cyan + '\n');
+    stdoutEqual(test, function() {
+      log.writeflags(['a', 'b'], 'Prefix');
+    }, 'Prefix: ' + 'a'.cyan + ', ' + 'b'.cyan + '\n');
+    stdoutEqual(test, function() {
+      log.writeflags({a: true, b: false, c: 0, d: null}, 'Prefix');
+    }, 'Prefix: ' + 'a'.cyan + ', ' + 'b=false'.cyan + ', ' + 'c=0'.cyan + ', ' + 'd=null'.cyan + '\n');
+
+    test.done();
+  },
+  'always': function(test) {
+    test.expect(3);
+    var log = new Log();
+
+    test.strictEqual(log.always, log);
+    test.strictEqual(log.verbose.always, log);
+    test.strictEqual(log.notverbose.always, log);
+
+    test.done();
+  },
+  'or': function(test) {
+    test.expect(2);
+    var log = new Log();
+
+    test.strictEqual(log.verbose.or, log.notverbose);
+    test.strictEqual(log.notverbose.or, log.verbose);
+
+    test.done();
+  },
+  'hasLogged': function(test) {
+    // Should only be true if output has been written!
+    test.expect(24);
+    var log = new Log();
+    test.equal(log.hasLogged, false);
+    test.equal(log.verbose.hasLogged, false);
+    test.equal(log.notverbose.hasLogged, false);
+    log.write('');
+    test.equal(log.hasLogged, true);
+    test.equal(log.verbose.hasLogged, true);
+    test.equal(log.notverbose.hasLogged, true);
+
+    log = new Log({verbose: true});
+    log.verbose.write('');
+    test.equal(log.hasLogged, true);
+    test.equal(log.verbose.hasLogged, true);
+    test.equal(log.notverbose.hasLogged, true);
+
+    log = new Log();
+    log.notverbose.write('');
+    test.equal(log.hasLogged, true);
+    test.equal(log.verbose.hasLogged, true);
+    test.equal(log.notverbose.hasLogged, true);
+
+    stdoutMute();
+    log = new Log({debug: true});
+    log.debug('');
+    test.equal(log.hasLogged, true);
+    test.equal(log.verbose.hasLogged, true);
+    test.equal(log.notverbose.hasLogged, true);
+    stdoutUnmute();
+
+    // The following should be false since there's a verbose mismatch!
+    log = new Log();
+    log.verbose.write('');
+    test.equal(log.hasLogged, false);
+    test.equal(log.verbose.hasLogged, false);
+    test.equal(log.notverbose.hasLogged, false);
+
+    log = new Log({verbose: true});
+    log.notverbose.write('');
+    test.equal(log.hasLogged, false);
+    test.equal(log.verbose.hasLogged, false);
+    test.equal(log.notverbose.hasLogged, false);
+
+    // The following should be false since there's a debug mismatch!
+    log = new Log();
+    log.debug('');
+    test.equal(log.hasLogged, false);
+    test.equal(log.verbose.hasLogged, false);
+    test.equal(log.notverbose.hasLogged, false);
+
+    test.done();
+  },
+  'muted': function(test) {
+    test.expect(30);
+    var log = new Log();
+
+    test.equal(log.muted, false);
+    test.equal(log.verbose.muted, false);
+    test.equal(log.notverbose.muted, false);
+    test.equal(log.options.muted, false);
+    test.equal(log.verbose.options.muted, false);
+    test.equal(log.notverbose.options.muted, false);
+
+    log.muted = true;
+    test.equal(log.muted, true);
+    test.equal(log.verbose.muted, true);
+    test.equal(log.notverbose.muted, true);
+    test.equal(log.options.muted, true);
+    test.equal(log.verbose.options.muted, true);
+    test.equal(log.notverbose.options.muted, true);
+
+    log.muted = false;
+    test.equal(log.muted, false);
+    test.equal(log.verbose.muted, false);
+    test.equal(log.notverbose.muted, false);
+    test.equal(log.options.muted, false);
+    test.equal(log.verbose.options.muted, false);
+    test.equal(log.notverbose.options.muted, false);
+
+    log.options.muted = true;
+    test.equal(log.muted, true);
+    test.equal(log.verbose.muted, true);
+    test.equal(log.notverbose.muted, true);
+    test.equal(log.options.muted, true);
+    test.equal(log.verbose.options.muted, true);
+    test.equal(log.notverbose.options.muted, true);
+
+    log.options.muted = false;
+    test.equal(log.muted, false);
+    test.equal(log.verbose.muted, false);
+    test.equal(log.notverbose.muted, false);
+    test.equal(log.options.muted, false);
+    test.equal(log.verbose.options.muted, false);
+    test.equal(log.notverbose.options.muted, false);
+
+    test.done();
+  },
+  'verbose': function(test) {
+    test.expect(15);
+    var log = new Log();
+    log.muted = true;
+
+    // Test verbose methods to make sure they always return the verbose object.
+    test.strictEqual(log.verbose.write(''), log.verbose);
+    test.strictEqual(log.verbose.writeln(''), log.verbose);
+    test.strictEqual(log.verbose.warn(''), log.verbose);
+    test.strictEqual(log.verbose.error(''), log.verbose);
+    test.strictEqual(log.verbose.ok(''), log.verbose);
+    test.strictEqual(log.verbose.errorlns(''), log.verbose);
+    test.strictEqual(log.verbose.oklns(''), log.verbose);
+    test.strictEqual(log.verbose.success(''), log.verbose);
+    test.strictEqual(log.verbose.fail(''), log.verbose);
+    test.strictEqual(log.verbose.header(''), log.verbose);
+    test.strictEqual(log.verbose.subhead(''), log.verbose);
+    test.strictEqual(log.verbose.debug(''), log.verbose);
+    test.strictEqual(log.verbose.writetableln([]), log.verbose);
+    test.strictEqual(log.verbose.writelns(''), log.verbose);
+    test.strictEqual(log.verbose.writeflags([]), log.verbose);
+
+    test.done();
+  },
+  'notverbose': function(test) {
+    test.expect(15);
+    var log = new Log();
+    log.muted = true;
+
+    // Test notverbose methods to make sure they always return the notverbose object.
+    test.strictEqual(log.notverbose.write(''), log.notverbose);
+    test.strictEqual(log.notverbose.writeln(''), log.notverbose);
+    test.strictEqual(log.notverbose.warn(''), log.notverbose);
+    test.strictEqual(log.notverbose.error(''), log.notverbose);
+    test.strictEqual(log.notverbose.ok(''), log.notverbose);
+    test.strictEqual(log.notverbose.errorlns(''), log.notverbose);
+    test.strictEqual(log.notverbose.oklns(''), log.notverbose);
+    test.strictEqual(log.notverbose.success(''), log.notverbose);
+    test.strictEqual(log.notverbose.fail(''), log.notverbose);
+    test.strictEqual(log.notverbose.header(''), log.notverbose);
+    test.strictEqual(log.notverbose.subhead(''), log.notverbose);
+    test.strictEqual(log.notverbose.debug(''), log.notverbose);
+    test.strictEqual(log.notverbose.writetableln([]), log.notverbose);
+    test.strictEqual(log.notverbose.writelns(''), log.notverbose);
+    test.strictEqual(log.notverbose.writeflags([]), log.notverbose);
+
+    test.done();
+  },
+  'options.debug = true': function(test) {
+    test.expect(4);
+    var log = new Log({debug: true});
+
+    stdoutEqual(test, function() { log.debug(); }, '[D] ' + ''.magenta + '\n');
+    stdoutEqual(test, function() { log.debug('foo'); }, '[D] ' + 'foo'.magenta + '\n');
+    stdoutEqual(test, function() { log.debug('%s', 'foo'); }, '[D] ' + 'foo'.magenta + '\n');
+    stdoutEqual(test, function() { log.debug(fooBuffer); }, '[D] ' + 'foo'.magenta + '\n');
+
+    test.done();
+  },
+  'options.verbose = false': function(test) {
+    test.expect(7);
+    var log = new Log({verbose: false});
+
+    stdoutEqual(test, function() { log.notverbose.write('foo'); }, 'foo');
+    stdoutEqual(test, function() { log.notverbose.write('%s', 'foo'); }, 'foo');
+    stdoutEqual(test, function() { log.notverbose.write(fooBuffer); }, 'foo');
+    stdoutEqual(test, function() { log.verbose.write('foo'); }, '');
+    stdoutEqual(test, function() { log.verbose.write('%s', 'foo'); }, '');
+    stdoutEqual(test, function() { log.verbose.write(fooBuffer); }, '');
+    stdoutEqual(test, function() { log.verbose.write('a').or.write('b'); }, 'b');
+
+    test.done();
+  },
+  'options.verbose = true': function(test) {
+    test.expect(7);
+    var log = new Log({verbose: true});
+
+    stdoutEqual(test, function() { log.verbose.write('foo'); }, 'foo');
+    stdoutEqual(test, function() { log.verbose.write('%s', 'foo'); }, 'foo');
+    stdoutEqual(test, function() { log.verbose.write(fooBuffer); }, 'foo');
+    stdoutEqual(test, function() { log.notverbose.write('foo'); }, '');
+    stdoutEqual(test, function() { log.notverbose.write('%s', 'foo'); }, '');
+    stdoutEqual(test, function() { log.notverbose.write(fooBuffer); }, '');
+    stdoutEqual(test, function() { log.notverbose.write('a').or.write('b'); }, 'b');
+
+    test.done();
+  },
+  'options.debug = false': function(test) {
+    test.expect(1);
+    var log = new Log({debug: false});
+
+    stdoutEqual(test, function() { log.debug('foo'); }, '');
+
+    test.done();
+  },
+  'options.color = true': function(test) {
+    test.expect(1);
+    var log = new Log({color: true});
+
+    stdoutEqual(test, function() { log.write('foo'.blue + 'bar'.underline); }, 'foo'.blue + 'bar'.underline);
+
+    test.done();
+  },
+  'options.color = false': function(test) {
+    test.expect(1);
+    var log = new Log({color: false});
+
+    stdoutEqual(test, function() { log.write('foo'.blue + 'bar'.underline); }, 'foobar');
+
+    test.done();
+  },
+  'perma-bind this when passing grunt in (backcompat)': function(test) {
+    test.expect(43);
+    var log = new Log({grunt: this.grunt});
+    stdoutMute();
+    [
+      'write',
+      'writeln',
+      'warn',
+      'error',
+      'ok',
+      'errorlns',
+      'oklns',
+      'success',
+      'fail',
+      'header',
+      'subhead',
+      'debug',
+    ].forEach(function(method) {
+      var fn = log[method];
+      var verboseFn = log.verbose[method];
+      var notVerboseFn = log.notverbose[method];
+      test.equal(fn(), log, 'Should return log if invoked in a way where this is not log.');
+      test.equal(verboseFn(), log.verbose, 'Should return log.verbose if invoked in a way where this is not log.');
+      test.equal(notVerboseFn(), log.notverbose, 'Should return log.notverbose if invoked in a way where this is not log.');
+    });
+
+    test.doesNotThrow(function() { var fn = log.writetableln; fn([]); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.writelns; fn([]); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.writeflags; fn([]); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.wordlist; fn([]); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.uncolor; fn(''); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.wraptext; fn(1,''); }, 'Should not throw if invoked in a way where this is not log.');
+    test.doesNotThrow(function() { var fn = log.table; fn([],''); }, 'Should not throw if invoked in a way where this is not log.');
+    stdoutUnmute();
+
+    test.done();
+  },
+};
+
+exports['Helpers'] = {
+  'uncolor': function(test) {
+    test.expect(2);
+    var log = new Log();
+    test.ok(log.uncolor);
+    test.strictEqual(log.uncolor, legacyLog.uncolor);
+    test.done();
+  },
+  'wordlist': function(test) {
+    test.expect(2);
+    var log = new Log();
+    test.ok(log.wordlist);
+    test.strictEqual(log.wordlist, legacyLog.wordlist);
+    test.done();
+  },
+  'wraptext': function(test) {
+    test.expect(2);
+    var log = new Log();
+    test.ok(log.wraptext);
+    test.strictEqual(log.wraptext, legacyLog.wraptext);
+    test.done();
+  },
+  'table': function(test) {
+    test.expect(2);
+    var log = new Log();
+    test.ok(log.table);
+    test.strictEqual(log.table, legacyLog.table);
+    test.done();
+  },
+};