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

   1 "use strict";
   2 var vows = require('vows')
   3 , assert = require('assert')
   4 , levels = require('../lib/levels');
   5
   6 function assertThat(level) {
   7   function assertForEach(assertion, test, otherLevels) {
   8     otherLevels.forEach(function(other) {
   9       assertion.call(assert, test.call(level, other));
  10     });
  11   }
  12
  13   return {
  14     isLessThanOrEqualTo: function(levels) {
  15       assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
  16     },
  17     isNotLessThanOrEqualTo: function(levels) {
  18       assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
  19     },
  20     isGreaterThanOrEqualTo: function(levels) {
  21       assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
  22     },
  23     isNotGreaterThanOrEqualTo: function(levels) {
  24       assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
  25     },
  26     isEqualTo: function(levels) {
  27       assertForEach(assert.isTrue, level.isEqualTo, levels);
  28     },
  29     isNotEqualTo: function(levels) {
  30       assertForEach(assert.isFalse, level.isEqualTo, levels);
  31     }
  32   };
  33 }
  34
  35 vows.describe('levels').addBatch({
  36   'values': {
  37     topic: levels,
  38     'should define some levels': function(levels) {
  39       assert.isNotNull(levels.ALL);
  40       assert.isNotNull(levels.TRACE);
  41       assert.isNotNull(levels.DEBUG);
  42       assert.isNotNull(levels.INFO);
  43       assert.isNotNull(levels.WARN);
  44       assert.isNotNull(levels.ERROR);
  45       assert.isNotNull(levels.FATAL);
  46       assert.isNotNull(levels.MARK);
  47       assert.isNotNull(levels.OFF);
  48     },
  49     'ALL': {
  50       topic: levels.ALL,
  51       'should be less than the other levels': function(all) {
  52         assertThat(all).isLessThanOrEqualTo(
  53           [
  54             levels.ALL,
  55             levels.TRACE,
  56             levels.DEBUG,
  57             levels.INFO,
  58             levels.WARN,
  59             levels.ERROR,
  60             levels.FATAL,
  61             levels.MARK,
  62             levels.OFF
  63           ]
  64         );
  65       },
  66       'should be greater than no levels': function(all) {
  67         assertThat(all).isNotGreaterThanOrEqualTo(
  68           [
  69             levels.TRACE,
  70             levels.DEBUG,
  71             levels.INFO,
  72             levels.WARN,
  73             levels.ERROR,
  74             levels.FATAL,
  75             levels.MARK,
  76             levels.OFF
  77           ]
  78         );
  79       },
  80       'should only be equal to ALL': function(all) {
  81         assertThat(all).isEqualTo([levels.toLevel("ALL")]);
  82         assertThat(all).isNotEqualTo(
  83           [
  84             levels.TRACE,
  85             levels.DEBUG,
  86             levels.INFO,
  87             levels.WARN,
  88             levels.ERROR,
  89             levels.FATAL,
  90             levels.MARK,
  91             levels.OFF
  92           ]
  93         );
  94       }
  95     },
  96     'TRACE': {
  97       topic: levels.TRACE,
  98       'should be less than DEBUG': function(trace) {
  99         assertThat(trace).isLessThanOrEqualTo(
 100           [
 101             levels.DEBUG,
 102             levels.INFO,
 103             levels.WARN,
 104             levels.ERROR,
 105             levels.FATAL,
 106             levels.MARK,
 107             levels.OFF
 108           ]
 109         );
 110         assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
 111       },
 112       'should be greater than ALL': function(trace) {
 113         assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
 114         assertThat(trace).isNotGreaterThanOrEqualTo(
 115           [
 116             levels.DEBUG,
 117             levels.INFO,
 118             levels.WARN,
 119             levels.ERROR,
 120             levels.FATAL,
 121             levels.MARK,
 122             levels.OFF
 123           ]
 124         );
 125       },
 126       'should only be equal to TRACE': function(trace) {
 127         assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
 128         assertThat(trace).isNotEqualTo(
 129           [
 130             levels.ALL,
 131             levels.DEBUG,
 132             levels.INFO,
 133             levels.WARN,
 134             levels.ERROR,
 135             levels.FATAL,
 136             levels.MARK,
 137             levels.OFF
 138           ]
 139         );
 140       }
 141     },
 142     'DEBUG': {
 143       topic: levels.DEBUG,
 144       'should be less than INFO': function(debug) {
 145         assertThat(debug).isLessThanOrEqualTo(
 146           [
 147             levels.INFO,
 148             levels.WARN,
 149             levels.ERROR,
 150             levels.FATAL,
 151             levels.MARK,
 152             levels.OFF
 153           ]
 154         );
 155         assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
 156       },
 157       'should be greater than TRACE': function(debug) {
 158         assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
 159         assertThat(debug).isNotGreaterThanOrEqualTo(
 160           [
 161             levels.INFO,
 162             levels.WARN,
 163             levels.ERROR,
 164             levels.FATAL,
 165             levels.MARK,
 166             levels.OFF
 167           ]
 168         );
 169       },
 170       'should only be equal to DEBUG': function(trace) {
 171         assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
 172         assertThat(trace).isNotEqualTo(
 173           [
 174             levels.ALL,
 175             levels.TRACE,
 176             levels.INFO,
 177             levels.WARN,
 178             levels.ERROR,
 179             levels.FATAL,
 180             levels.MARK,
 181             levels.OFF
 182           ]
 183         );
 184       }
 185     },
 186     'INFO': {
 187       topic: levels.INFO,
 188       'should be less than WARN': function(info) {
 189         assertThat(info).isLessThanOrEqualTo([
 190           levels.WARN,
 191           levels.ERROR,
 192           levels.FATAL,
 193           levels.MARK,
 194           levels.OFF
 195         ]);
 196         assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
 197       },
 198       'should be greater than DEBUG': function(info) {
 199         assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
 200         assertThat(info).isNotGreaterThanOrEqualTo([
 201           levels.WARN,
 202           levels.ERROR,
 203           levels.FATAL,
 204           levels.MARK,
 205           levels.OFF
 206         ]);
 207       },
 208       'should only be equal to INFO': function(trace) {
 209         assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
 210         assertThat(trace).isNotEqualTo([
 211           levels.ALL,
 212           levels.TRACE,
 213           levels.DEBUG,
 214           levels.WARN,
 215           levels.ERROR,
 216           levels.FATAL,
 217           levels.MARK,
 218           levels.OFF
 219         ]);
 220       }
 221     },
 222     'WARN': {
 223       topic: levels.WARN,
 224       'should be less than ERROR': function(warn) {
 225         assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.MARK, levels.OFF]);
 226         assertThat(warn).isNotLessThanOrEqualTo([
 227           levels.ALL,
 228           levels.TRACE,
 229           levels.DEBUG,
 230           levels.INFO
 231         ]);
 232       },
 233       'should be greater than INFO': function(warn) {
 234         assertThat(warn).isGreaterThanOrEqualTo([
 235           levels.ALL,
 236           levels.TRACE,
 237           levels.DEBUG,
 238           levels.INFO
 239         ]);
 240         assertThat(warn).isNotGreaterThanOrEqualTo([
 241           levels.ERROR, levels.FATAL, levels.MARK, levels.OFF
 242         ]);
 243       },
 244       'should only be equal to WARN': function(trace) {
 245         assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
 246         assertThat(trace).isNotEqualTo([
 247           levels.ALL,
 248           levels.TRACE,
 249           levels.DEBUG,
 250           levels.INFO,
 251           levels.ERROR,
 252           levels.FATAL,
 253           levels.OFF
 254         ]);
 255       }
 256     },
 257     'ERROR': {
 258       topic: levels.ERROR,
 259       'should be less than FATAL': function(error) {
 260         assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.MARK, levels.OFF]);
 261         assertThat(error).isNotLessThanOrEqualTo([
 262           levels.ALL,
 263           levels.TRACE,
 264           levels.DEBUG,
 265           levels.INFO,
 266           levels.WARN
 267         ]);
 268       },
 269       'should be greater than WARN': function(error) {
 270         assertThat(error).isGreaterThanOrEqualTo([
 271           levels.ALL,
 272           levels.TRACE,
 273           levels.DEBUG,
 274           levels.INFO,
 275           levels.WARN
 276         ]);
 277         assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.MARK, levels.OFF]);
 278       },
 279       'should only be equal to ERROR': function(trace) {
 280         assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
 281         assertThat(trace).isNotEqualTo([
 282           levels.ALL,
 283           levels.TRACE,
 284           levels.DEBUG,
 285           levels.INFO,
 286           levels.WARN,
 287           levels.FATAL,
 288           levels.MARK,
 289           levels.OFF
 290         ]);
 291       }
 292     },
 293     'FATAL': {
 294       topic: levels.FATAL,
 295       'should be less than OFF': function(fatal) {
 296         assertThat(fatal).isLessThanOrEqualTo([levels.MARK, levels.OFF]);
 297         assertThat(fatal).isNotLessThanOrEqualTo([
 298           levels.ALL,
 299           levels.TRACE,
 300           levels.DEBUG,
 301           levels.INFO,
 302           levels.WARN,
 303           levels.ERROR
 304         ]);
 305       },
 306       'should be greater than ERROR': function(fatal) {
 307         assertThat(fatal).isGreaterThanOrEqualTo([
 308           levels.ALL,
 309           levels.TRACE,
 310           levels.DEBUG,
 311           levels.INFO,
 312           levels.WARN,
 313           levels.ERROR
 314        ]);
 315         assertThat(fatal).isNotGreaterThanOrEqualTo([levels.MARK, levels.OFF]);
 316       },
 317       'should only be equal to FATAL': function(fatal) {
 318         assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
 319         assertThat(fatal).isNotEqualTo([
 320           levels.ALL,
 321           levels.TRACE,
 322           levels.DEBUG,
 323           levels.INFO,
 324           levels.WARN,
 325           levels.ERROR,
 326           levels.MARK,
 327           levels.OFF
 328         ]);
 329       }
 330     },
 331     'MARK': {
 332       topic: levels.MARK,
 333       'should be less than OFF': function(mark) {
 334         assertThat(mark).isLessThanOrEqualTo([levels.OFF]);
 335         assertThat(mark).isNotLessThanOrEqualTo([
 336           levels.ALL,
 337           levels.TRACE,
 338           levels.DEBUG,
 339           levels.INFO,
 340           levels.WARN,
 341           levels.FATAL,
 342           levels.ERROR
 343         ]);
 344       },
 345       'should be greater than FATAL': function(mark) {
 346         assertThat(mark).isGreaterThanOrEqualTo([
 347           levels.ALL,
 348           levels.TRACE,
 349           levels.DEBUG,
 350           levels.INFO,
 351           levels.WARN,
 352           levels.ERROR,
 353           levels.FATAL
 354        ]);
 355         assertThat(mark).isNotGreaterThanOrEqualTo([levels.OFF]);
 356       },
 357       'should only be equal to MARK': function(mark) {
 358         assertThat(mark).isEqualTo([levels.toLevel("MARK")]);
 359         assertThat(mark).isNotEqualTo([
 360           levels.ALL,
 361           levels.TRACE,
 362           levels.DEBUG,
 363           levels.INFO,
 364           levels.WARN,
 365           levels.ERROR,
 366           levels.FATAL,
 367           levels.OFF
 368         ]);
 369       }
 370     },
 371     'OFF': {
 372       topic: levels.OFF,
 373       'should not be less than anything': function(off) {
 374         assertThat(off).isNotLessThanOrEqualTo([
 375           levels.ALL,
 376           levels.TRACE,
 377           levels.DEBUG,
 378           levels.INFO,
 379           levels.WARN,
 380           levels.ERROR,
 381           levels.FATAL,
 382           levels.MARK
 383         ]);
 384       },
 385       'should be greater than everything': function(off) {
 386         assertThat(off).isGreaterThanOrEqualTo([
 387           levels.ALL,
 388           levels.TRACE,
 389           levels.DEBUG,
 390           levels.INFO,
 391           levels.WARN,
 392           levels.ERROR,
 393           levels.FATAL,
 394           levels.MARK
 395         ]);
 396       },
 397       'should only be equal to OFF': function(off) {
 398         assertThat(off).isEqualTo([levels.toLevel("OFF")]);
 399         assertThat(off).isNotEqualTo([
 400           levels.ALL,
 401           levels.TRACE,
 402           levels.DEBUG,
 403           levels.INFO,
 404           levels.WARN,
 405           levels.ERROR,
 406           levels.FATAL,
 407           levels.MARK
 408         ]);
 409       }
 410     }
 411   },
 412   'isGreaterThanOrEqualTo': {
 413     topic: levels.INFO,
 414     'should handle string arguments': function(info) {
 415       assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
 416       assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'MARK', 'off']);
 417     }
 418   },
 419   'isLessThanOrEqualTo': {
 420     topic: levels.INFO,
 421     'should handle string arguments': function(info) {
 422       assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
 423       assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'MARK', 'off']);
 424     }
 425   },
 426   'isEqualTo': {
 427     topic: levels.INFO,
 428     'should handle string arguments': function(info) {
 429       assertThat(info).isEqualTo(["info", "INFO", "iNfO"]);
 430     }
 431   },
 432   'toLevel': {
 433     'with lowercase argument': {
 434       topic: levels.toLevel("debug"),
 435       'should take the string and return the corresponding level': function(level) {
 436         assert.equal(level, levels.DEBUG);
 437       }
 438     },
 439     'with uppercase argument': {
 440       topic: levels.toLevel("DEBUG"),
 441       'should take the string and return the corresponding level': function(level) {
 442         assert.equal(level, levels.DEBUG);
 443       }
 444     },
 445     'with varying case': {
 446       topic: levels.toLevel("DeBuG"),
 447       'should take the string and return the corresponding level': function(level) {
 448         assert.equal(level, levels.DEBUG);
 449       }
 450     },
 451     'with unrecognised argument': {
 452       topic: levels.toLevel("cheese"),
 453       'should return undefined': function(level) {
 454         assert.isUndefined(level);
 455       }
 456     },
 457     'with unrecognised argument and default value': {
 458       topic: levels.toLevel("cheese", levels.DEBUG),
 459       'should return default value': function(level) {
 460         assert.equal(level, levels.DEBUG);
 461       }
 462     }
 463   }
 464 }).export(module);