more tests, add the missing coveralls script, add ci build and covera…

…ge buttons

Readme.md

@@ -1,6 +1,9 @@
 qlogger
 =======
 
+[![Build Status](https://travis-ci.org/andrasq/qlogger.svg?branch=master)](https://travis-ci.org/andrasq/qlogger)
+[![Coverage Status](https://coveralls.io/repos/github/andrasq/qlogger/badge.svg?branch=master)](https://coveralls.io/github/andrasq/qlogger?branch=master)
+
 quick nodejs logging and newline delimited data transport
 
 QLogger is a toolkit for building very fast loggers.  It can be used out of

lib/qlogger.js

@@ -51,7 +51,7 @@ QLogger.LOGLEVELS = {
     ERROR: 3,   error: 3,       Error: 3,               LOG_ERROR: 3,
 };
 QLogger.LEVELNAMES = [
-    , , , 'error', 'warning', , 'info', 'debug', , 'all'
+    'emerg', 'alert', 'crit', 'error', 'warning', 'notice', 'info', 'debug', '-8-', 'all'
 ];
 
 /**
@@ -247,24 +247,19 @@ QLogger.createWriter = function createWriter( writerSpec, callback ) {
         switch (type) {
         case 'null':
             return callbackOrReturn(null, {write: function(str, cb) { cb(); }});
-            break;
         case 'file':
             if (name === '-') return callbackOrReturn(null, process.stdout);
             return callbackOrReturn(null, new Fputs(new Fputs.FileWriter(name, 'a')));
-            break;
         case 'stdout':
             return callbackOrReturn(null, process.stdout);
-            break;
         case 'stderr':
             return callbackOrReturn(null, process.stderr);
-            break;
         case 'tcp':
             hostport = name.split(":");
             socket = net.connect({host: hostport[0], port: hostport[1]});
             return (!socket)
                 ? callbackOrReturn(new Error(writerSpec + ": unable to connect to tcp endpoint"))
                 : callbackOrReturn(false, socket);
-            break;
         case 'udp':
             var dgram = require('dgram');
             hostport = name.split(":");
@@ -281,10 +276,8 @@ QLogger.createWriter = function createWriter( writerSpec, callback ) {
                 socket.send(buf, 0, buf.length, hostport[1], hostport[0], cb);
             }
             return callbackOrReturn(false, socket);
-            break;
         default:
             throw new Error(writerSpec + ": unrecognized log writer spec");
-            break;
         }
     }
     catch (err) {

package.json

@@ -16,7 +16,10 @@
     "node": ">=0.8"
   },
   "scripts": {
-    "test": "env TZ=America/New_York qnit test"
+    "test": "env TZ=America/New_York qnit test",
+    "coverage": "nyc --reporter lcov --reporter text npm test",
+    "clean": "rm -rf .nyc_output coverage",
+    "coveralls": "nyc --reporter text-lcov npm test | coveralls"
   },
   "keywords": [
     "Andras",

test/test-qlogger.js

@@ -40,6 +40,32 @@ module.exports = {
     },
 
     'instance': {
+        'constructor should create writer by name': function(t) {
+            var logger = new QLogger('info', 'null://');
+            t.deepEqual(Object.keys(logger._writers[0]), ['write']);
+            t.done();
+        },
+
+        'constructor should accept a writer object': function(t) {
+            var writer = {write: function(){}};
+            var logger = new QLogger('info', writer);
+            t.equal(logger._writers[0], writer);
+            t.done();
+        },
+
+        'constructor should work as a factory without new': function(t) {
+            var logger = QLogger();
+            t.ok(logger instanceof QLogger);
+            t.done();
+        },
+
+        'constructor should throw on invalid loglevel': function(t) {
+            t.throws(function() {
+                new QLogger('nonesuch');
+            })
+            t.done();
+        },
+
         'should export the logging methods': function(t) {
             var methods = ['error', 'err', 'warning', 'warn', 'info', 'debug'];
             var i;
@@ -60,6 +86,14 @@ module.exports = {
             }
             t.done();
         },
+
+        'loglevel should throw on invalid loglevel': function(t) {
+            var logger = this.logger;
+            t.throws(function() {
+                logger.loglevel('nonesuch');
+            })
+            t.done();
+        },
     },
 
     'logging': {
@@ -105,9 +139,51 @@ module.exports = {
             t.deepEqual(calls[0].msg, [1,2,3]);
             t.done();
         },
+
+        'should omit empty messages': function(t) {
+            this.logger.info("");
+            t.equal(this.lines.length, 0);
+            t.done();
+        },
+    },
+
+    'errors': {
+        'should gather write erorrs and report them to fflush': function(t) {
+            var writer = {write: function(str, cb) { return cb(new Error("write error")) }};
+            var logger = this.logger;
+            logger.addWriter(writer);
+            logger.info('test');
+            t.equal(logger._writeErrors.length, 1);
+            t.equal(logger._writeErrors[0].message, "write error");
+            logger.fflush(function(err) {
+                t.ok(err);
+                t.equal(err.message, "write error");
+                t.equal(logger._writeErrors.length, 0);
+                t.done();
+            })
+        },
+
+        'should report fflush errors': function(t) {
+            var writer = {write: function(str, cb) { cb() }, fflush: function(cb) { cb(new Error("fflush error")) }};
+            var logger = this.logger;
+            logger.addWriter(writer);
+            logger.fflush(function(err, ret) {
+                t.ok(err);
+                t.equal(err.message, "fflush error");
+                t.done();
+            })
+        },
     },
 
     'writers': {
+        'should create functional null:// mock writer': function(t) {
+            var writer = QLogger.createWriter('null://');
+            writer.write("test", function(err) {
+                t.ifError(err);
+                t.done();
+            })
+        },
+
         'should create file://- stdout writer': function(t) {
             var writer = QLogger.createWriter('file://-');
             t.equal(process.stdout, writer);
@@ -143,8 +219,9 @@ module.exports = {
             writer.on('connect', function() {
                 writer.end();
                 t.ok(writer);
-                server.close();
-                t.done();
+                server.close(function() {
+                    t.done();
+                });
             });
         },
 
@@ -156,6 +233,19 @@ module.exports = {
             t.done();
         },
 
+        'udp:// writer should return error if line too long': function(t) {
+            var writer = QLogger.createWriter('udp://localhost:80');
+            var stub = t.stub(process.stderr, 'write');
+            writer.write("xxx", function(err) {
+                t.ifError(err);
+                writer.write(new Array(70000).join('x'), function(err) {
+                    t.ok(err);
+                    stub.restore();
+                    t.done();
+                });
+            })
+        },
+
         'should create file:// writer': function(t) {
             var writer = QLogger.createWriter('file:///tmp/nodeunit.test.out');
             t.ok(writer);
@@ -177,6 +267,21 @@ module.exports = {
                 t.done();
             });
         },
+
+        'should throw on invalid writer selector': function(t) {
+            t.throws(function() {
+                QLogger.createWriter('nonesuch://');
+                t.fail("did not throw");
+            })
+            t.done();
+        },
+
+        'should return error on invalid writer selector': function(t) {
+            QLogger.createWriter('nonesuch://', function(err) {
+                t.ok(err);
+                t.done();
+            })
+        },
     },
 
     'filters': {