vnfmarket/src/main/webapp/vnfmarket/node_modules/log4js/test/multiprocess-test.js

   1 "use strict";
   2 var vows = require('vows')
   3 , sandbox = require('sandboxed-module')
   4 , assert = require('assert')
   5 ;
   6
   7 function makeFakeNet() {
   8   return {
   9     logEvents: [],
  10     data: [],
  11     cbs: {},
  12     createConnectionCalled: 0,
  13     fakeAppender: function(logEvent) {
  14       this.logEvents.push(logEvent);
  15     },
  16     createConnection: function(port, host) {
  17       var fakeNet = this;
  18       this.port = port;
  19       this.host = host;
  20       this.createConnectionCalled += 1;
  21       return {
  22         on: function(evt, cb) {
  23           fakeNet.cbs[evt] = cb;
  24         },
  25         write: function(data, encoding) {
  26           fakeNet.data.push(data);
  27           fakeNet.encoding = encoding;
  28         },
  29         end: function() {
  30           fakeNet.closeCalled = true;
  31         }
  32       };
  33     },
  34     createServer: function(cb) {
  35       var fakeNet = this;
  36       cb({
  37         remoteAddress: '1.2.3.4',
  38         remotePort: '1234',
  39         setEncoding: function(encoding) {
  40           fakeNet.encoding = encoding;
  41         },
  42         on: function(event, cb) {
  43           fakeNet.cbs[event] = cb;
  44         }
  45       });
  46
  47       return {
  48         listen: function(port, host) {
  49           fakeNet.port = port;
  50           fakeNet.host = host;
  51         }
  52       };
  53     }
  54   };
  55 }
  56
  57 vows.describe('Multiprocess Appender').addBatch({
  58   'worker': {
  59     topic: function() {
  60       var fakeNet = makeFakeNet(),
  61       appender = sandbox.require(
  62         '../lib/appenders/multiprocess',
  63         {
  64           requires: {
  65             'net': fakeNet
  66           }
  67         }
  68       ).appender({ mode: 'worker', loggerPort: 1234, loggerHost: 'pants' });
  69
  70       //don't need a proper log event for the worker tests
  71       appender('before connect');
  72       fakeNet.cbs.connect();
  73       appender('after connect');
  74       fakeNet.cbs.close(true);
  75       appender('after error, before connect');
  76       fakeNet.cbs.connect();
  77       appender('after error, after connect');
  78           appender(new Error('Error test'));
  79
  80       return fakeNet;
  81     },
  82     'should open a socket to the loggerPort and loggerHost': function(net) {
  83       assert.equal(net.port, 1234);
  84       assert.equal(net.host, 'pants');
  85     },
  86     'should buffer messages written before socket is connected': function(net) {
  87       assert.equal(net.data[0], JSON.stringify('before connect'));
  88     },
  89     'should write log messages to socket as json strings with a terminator string': function(net) {
  90       assert.equal(net.data[0], JSON.stringify('before connect'));
  91       assert.equal(net.data[1], '__LOG4JS__');
  92       assert.equal(net.data[2], JSON.stringify('after connect'));
  93       assert.equal(net.data[3], '__LOG4JS__');
  94       assert.equal(net.encoding, 'utf8');
  95     },
  96     'should attempt to re-open the socket on error': function(net) {
  97       assert.equal(net.data[4], JSON.stringify('after error, before connect'));
  98       assert.equal(net.data[5], '__LOG4JS__');
  99       assert.equal(net.data[6], JSON.stringify('after error, after connect'));
 100       assert.equal(net.data[7], '__LOG4JS__');
 101       assert.equal(net.createConnectionCalled, 2);
 102     },
 103     'should serialize an Error correctly': function(net) {
 104       assert(
 105         JSON.parse(net.data[8]).stack,
 106         "Expected:\n\n" + net.data[8] + "\n\n to have a 'stack' property"
 107       );
 108       var actual = JSON.parse(net.data[8]).stack;
 109       var expectedRegex = /^Error: Error test/;
 110       assert(
 111         actual.match(expectedRegex),
 112         "Expected: \n\n " + actual + "\n\n to match " + expectedRegex
 113       );
 114
 115     }
 116   },
 117   'worker with timeout': {
 118     topic: function() {
 119       var fakeNet = makeFakeNet(),
 120       appender = sandbox.require(
 121         '../lib/appenders/multiprocess',
 122         {
 123           requires: {
 124             'net': fakeNet
 125           }
 126         }
 127       ).appender({ mode: 'worker' });
 128
 129       //don't need a proper log event for the worker tests
 130       appender('before connect');
 131       fakeNet.cbs.connect();
 132       appender('after connect');
 133       fakeNet.cbs.timeout();
 134       appender('after timeout, before close');
 135       fakeNet.cbs.close();
 136       appender('after close, before connect');
 137       fakeNet.cbs.connect();
 138       appender('after close, after connect');
 139
 140       return fakeNet;
 141     },
 142     'should attempt to re-open the socket': function(net) {
 143       //skipping the __LOG4JS__ separators
 144       assert.equal(net.data[0], JSON.stringify('before connect'));
 145       assert.equal(net.data[2], JSON.stringify('after connect'));
 146       assert.equal(net.data[4], JSON.stringify('after timeout, before close'));
 147       assert.equal(net.data[6], JSON.stringify('after close, before connect'));
 148       assert.equal(net.data[8], JSON.stringify('after close, after connect'));
 149       assert.equal(net.createConnectionCalled, 2);
 150     }
 151   },
 152   'worker defaults': {
 153     topic: function() {
 154       var fakeNet = makeFakeNet(),
 155       appender = sandbox.require(
 156         '../lib/appenders/multiprocess',
 157         {
 158           requires: {
 159             'net': fakeNet
 160           }
 161         }
 162       ).appender({ mode: 'worker' });
 163
 164       return fakeNet;
 165     },
 166     'should open a socket to localhost:5000': function(net) {
 167       assert.equal(net.port, 5000);
 168       assert.equal(net.host, 'localhost');
 169     }
 170   },
 171   'master': {
 172     topic: function() {
 173       var fakeNet = makeFakeNet(),
 174       appender = sandbox.require(
 175         '../lib/appenders/multiprocess',
 176         {
 177           requires: {
 178             'net': fakeNet
 179           }
 180         }
 181       ).appender({ mode: 'master',
 182                    loggerHost: 'server',
 183                    loggerPort: 1234,
 184                    actualAppender: fakeNet.fakeAppender.bind(fakeNet)
 185                  });
 186
 187       appender('this should be sent to the actual appender directly');
 188
 189       return fakeNet;
 190     },
 191     'should listen for log messages on loggerPort and loggerHost': function(net) {
 192       assert.equal(net.port, 1234);
 193       assert.equal(net.host, 'server');
 194     },
 195     'should return the underlying appender': function(net) {
 196       assert.equal(net.logEvents[0], 'this should be sent to the actual appender directly');
 197     },
 198     'when a client connects': {
 199       topic: function(net) {
 200         var logString = JSON.stringify(
 201           { level: { level: 10000, levelStr: 'DEBUG' }
 202             , data: ['some debug']}
 203         ) + '__LOG4JS__';
 204
 205         net.cbs.data(
 206           JSON.stringify(
 207             { level: { level: 40000, levelStr: 'ERROR' }
 208               , data: ['an error message'] }
 209           ) + '__LOG4JS__'
 210         );
 211         net.cbs.data(logString.substring(0, 10));
 212         net.cbs.data(logString.substring(10));
 213         net.cbs.data(logString + logString + logString);
 214         net.cbs.end(
 215           JSON.stringify(
 216             { level:  { level: 50000, levelStr: 'FATAL' }
 217               , data: ["that's all folks"] }
 218           ) + '__LOG4JS__'
 219         );
 220         net.cbs.data('bad message__LOG4JS__');
 221         return net;
 222       },
 223       'should parse log messages into log events and send to appender': function(net) {
 224         assert.equal(net.logEvents[1].level.toString(), 'ERROR');
 225         assert.equal(net.logEvents[1].data[0], 'an error message');
 226         assert.equal(net.logEvents[1].remoteAddress, '1.2.3.4');
 227         assert.equal(net.logEvents[1].remotePort, '1234');
 228       },
 229       'should parse log messages split into multiple chunks': function(net) {
 230         assert.equal(net.logEvents[2].level.toString(), 'DEBUG');
 231         assert.equal(net.logEvents[2].data[0], 'some debug');
 232         assert.equal(net.logEvents[2].remoteAddress, '1.2.3.4');
 233         assert.equal(net.logEvents[2].remotePort, '1234');
 234       },
 235       'should parse multiple log messages in a single chunk': function(net) {
 236         assert.equal(net.logEvents[3].data[0], 'some debug');
 237         assert.equal(net.logEvents[4].data[0], 'some debug');
 238         assert.equal(net.logEvents[5].data[0], 'some debug');
 239       },
 240       'should handle log messages sent as part of end event': function(net) {
 241         assert.equal(net.logEvents[6].data[0], "that's all folks");
 242       },
 243       'should handle unparseable log messages': function(net) {
 244         assert.equal(net.logEvents[7].level.toString(), 'ERROR');
 245         assert.equal(net.logEvents[7].categoryName, 'log4js');
 246         assert.equal(net.logEvents[7].data[0], 'Unable to parse log:');
 247         assert.equal(net.logEvents[7].data[1], 'bad message');
 248       }
 249     }
 250   },
 251   'master defaults': {
 252     topic: function() {
 253       var fakeNet = makeFakeNet(),
 254       appender = sandbox.require(
 255         '../lib/appenders/multiprocess',
 256         {
 257           requires: {
 258             'net': fakeNet
 259           }
 260         }
 261       ).appender({ mode: 'master' });
 262
 263       return fakeNet;
 264     },
 265     'should listen for log messages on localhost:5000': function(net) {
 266       assert.equal(net.port, 5000);
 267       assert.equal(net.host, 'localhost');
 268     }
 269   }
 270 }).addBatch({
 271   'configure': {
 272     topic: function() {
 273       var results = {}
 274       , fakeNet = makeFakeNet()
 275       , appender = sandbox.require(
 276         '../lib/appenders/multiprocess',
 277         {
 278           requires: {
 279             'net': fakeNet,
 280             '../log4js': {
 281               loadAppender: function(app) {
 282                 results.appenderLoaded = app;
 283               },
 284               appenderMakers: {
 285                 'madeupappender': function(config, options) {
 286                   results.config = config;
 287                   results.options = options;
 288                 }
 289               }
 290             }
 291           }
 292         }
 293       ).configure(
 294         {
 295           mode: 'master',
 296           appender: {
 297             type: 'madeupappender',
 298             cheese: 'gouda'
 299           }
 300         },
 301         { crackers: 'jacobs' }
 302       );
 303
 304       return results;
 305
 306     },
 307     'should load underlying appender for master': function(results) {
 308       assert.equal(results.appenderLoaded, 'madeupappender');
 309     },
 310     'should pass config to underlying appender': function(results) {
 311       assert.equal(results.config.cheese, 'gouda');
 312     },
 313     'should pass options to underlying appender': function(results) {
 314       assert.equal(results.options.crackers, 'jacobs');
 315     }
 316   }
 317 }).exportTo(module);