83 | * * Twitter: [http://twitter.com/c2fo](http://twitter.com/c2fo) - 877.465.4045
84 | */
85 |
86 | /**
87 | * Utilities for javascript, optimized for the server environment.
88 | *
89 | *
90 | * @namespace
91 | * @ignoreCode
92 | */
93 | var comb = createExtension;
94 | base.merge(comb, base, require("./define"), require("./promise"), require("./async"), require("./plugins"), require("./collections"), require("./logging"));
95 |
96 |
97 | comb.definePlugin = function (obj) {
98 | if (comb.isHash(obj)) {
99 | comb.deepMerge(comb, obj);
100 | }
101 | return comb;
102 | };
103 |
104 | module.exports = comb;
105 |
106 |
107 |
108 |
109 |
110 |
--------------------------------------------------------------------------------
/lib/logging/appenders/consoleAppender.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var define = require("../../define.js").define,
3 | base = require("../../base"),
4 | string = base.string,
5 | style = string.style,
6 | format = string.format,
7 | Appender = require("./appender"),
8 | Level = require("../level");
9 |
10 | /**
11 | * @class Appends messages to the console.
12 | *
13 | * @name ConsoleAppender
14 | * @augments comb.logging.appenders.Appender
15 | * @memberOf comb.logging.appenders
16 | */
17 |
18 | Appender.extend({
19 | instance: {
20 |
21 | constructor: function (options) {
22 | options = options || {};
23 | !options.name && (options.name = "consoleAppender");
24 | this.__wrapStyle = options.wrapStyle;
25 | if (!("wrapStyle" in options)) {
26 | this.__wrapStyle = true;
27 | }
28 | this._super(arguments, [options]);
29 | },
30 |
31 | getLevelColor: function (level) {
32 | if (Level.ERROR.equals(level) || Level.FATAL.equals(level)) {
33 | return "red";
34 | } else if (Level.WARN.equals(level)) {
35 | return "yellow";
36 | } else if (Level.DEBUG.equals(level)) {
37 | return "cyan";
38 | } else if (Level.TRACE.equals(level)) {
39 | return "magenta";
40 | } else if (Level.INFO.equals(level)) {
41 | return "blue";
42 | }
43 | return null;
44 | },
45 |
46 | extraEventData: function (event) {
47 | var level = event.level,
48 | color = this.getLevelColor(level);
49 | return base.merge({
50 | levelNameColored: color ? style(level.name, color) : level,
51 | }, event);
52 | },
53 |
54 | append: function (event) {
55 | if (this._canAppend(event)) {
56 | var level = event.level,
57 | message = format(this.__pattern, this.extraEventData(event));
58 | if (this.__wrapStyle) {
59 | console.log(style(message, this.getLevelColor(level)));
60 | } else {
61 | console.log(message);
62 | }
63 | }
64 | }
65 | }
66 | }).registerType("ConsoleAppender").as(module);
--------------------------------------------------------------------------------
/lib/logging/appenders/fileAppender.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var define = require("../../define.js").define,
3 | base = require("../../base"),
4 | promise = require("../../promise"),
5 | string = base.string,
6 | Promise = promise.Promise,
7 | PromiseList = promise.PromiseList,
8 | style = string.style,
9 | format = string.format,
10 | Appender = require("./appender"),
11 | Level = require("../level"),
12 | fs = require("fs");
13 |
14 |
15 | /**
16 | * @class Appends messages to a file.
17 | *
18 | * @example
19 | * var fileAppender = new comb.logging.appenders.FileAppender({
20 | * file : "/var/log/myLog.log"
21 | * });
22 | *
23 | *
24 | * @name FileAppender
25 | * @augments comb.logging.appenders.Appender
26 | * @memberOf comb.logging.appenders
27 | *
28 | * @param {Object} [options] options to assign to this Appender
29 | * @param {String} [options.name="appender"] the name of this Appender. If you want two of the same type of appender
30 | * on a logger it must have a different name.
31 | * @param {String} [options.pattern="[{[yyyy-MM-ddTHH:mm:ss:SSS (z)]timeStamp}] {[- 5]levelName} {[-20]name} - {message}"]
32 | * Available Options for formatting see {@link comb.string.format} for formatting options
33 | *
34 | * - timeStamp - the timestamp of the event being logged
35 | * - level - the {@link comb.logging.Level} of the event
36 | * - levelName - the name of the level being logged
37 | * - name - the name of the logger logging the event
38 | * - message - the message being logged
39 | *
40 | * @param {comb.logging.Level|String} [options.level=comb.logging.Level.INFO] the logging level of this appender
41 | * Note: the level can be different from the logger in the case that you want a particular logger
42 | * to only log particular event of a level. For example an appender that only logs errors. BEWARE that if the
43 | * appenders level is lower than the logger is will not recieve any messages.
44 | *
45 | * @param {String} [options.file="./log.log"] the file to log events to.
46 | * @param {String} [options.encoding="utf8"] the encoding of the file.
47 | * @param {Boolean} [options.overwrite=false] if true the log file is overwritten otherwise it is appended to.
48 | * @ignoreCode
49 | */
50 | Appender.extend({
51 | instance: {
52 |
53 | constructor: function (options) {
54 | options = options || {};
55 | !options.name && (options.name = "fileAppender");
56 | this.__file = options.file || "./log.log";
57 | this.__encoding = options.encoding || "utf8";
58 | this.__overwrite = options.overwrite || false;
59 | this.__writeStream = options.writeStream || fs.createWriteStream(this.__file, {
60 | flags: this.__overwrite ? "w" : 'a',
61 | encoding: this.__encoding
62 | });
63 | this._super([options]);
64 | this.__pattern += "\n";
65 | base.listenForExit(base.hitch(this, "__onExit"));
66 | },
67 |
68 |
69 | __onExit: function () {
70 | var ret = new Promise();
71 | var ws = this.__writeStream;
72 | this.__writeStream = null;
73 | ws.on("close", base.hitch(ret, "callback"));
74 | ws.destroySoon();
75 | return ret.promise();
76 | },
77 |
78 | append: function (event) {
79 | var ws = this.__writeStream;
80 | if (this._canAppend(event) && ws && ws.writable) {
81 | var message = format(this.__pattern, event);
82 | var level = event.level;
83 | ws.write(message);
84 | }
85 | }
86 | }
87 | }).registerType("FileAppender").as(module);
--------------------------------------------------------------------------------
/lib/logging/appenders/index.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | /**@ignore*/
3 | exports.Appender = require("./appender");
4 | /**@ignore*/
5 | exports.ConsoleAppender = require("./consoleAppender");
6 | /**@ignore*/
7 | exports.FileAppender = require("./fileAppender");
8 | /**@ignore*/
9 | exports.JSONAppender = require("./jsonAppender");
10 | /**@ignore*/
11 | exports.RollingFileAppender = require("./rollingFileAppender");
12 |
13 |
--------------------------------------------------------------------------------
/lib/logging/appenders/jsonAppender.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var define = require("../../define.js").define,
3 | base = require("../../base"),
4 | string = base.string,
5 | escape = base.regexp.escapeString,
6 | FileAppender = require("./fileAppender"),
7 | format = string.format,
8 | Level = require("../level"),
9 | fs = require("fs");
10 |
11 |
12 | /**
13 | * @class Appends messages to a file in JSON format. The messages are logged to an array in a JSON file
14 | * The file is always overwritten
15 | *
16 | * @example
17 | * //example log.json
18 | * [
19 | * {
20 | * "timestamp" : "Wed Jun 08 2011 11:16:20 GMT-0500 (CDT)",
21 | * "level" : "INFO",
22 | * "name" : "comb",
23 | * "message" : "INFO MESSAGE!!!!"
24 | * }
25 | * ]
26 | *
27 | *
28 | * @name JSONAppender
29 | * @augments comb.logging.appenders.FileAppender
30 | * @memberOf comb.logging.appenders
31 | *
32 | * @param {Object} [options] options to assign to this Appender
33 | * @param {String} [options.name="appender"] the name of this Appender. If you want two of the same type of appender
34 | * on a logger it must have a different name.
35 | * @param {String} [options.pattern="{"timestamp" : "{timeStamp}", "level" : "{levelName}", "name" : "{name}", "message" : "{message}"}"]
36 | * Available Options for formatting see {@link comb.string.format} for formatting options
37 | *
38 | * - timeStamp - the timestamp of the event being logged
39 | * - level - the {@link comb.logging.Level} of the event
40 | * - levelName - the name of the level being logged
41 | * - name - the name of the logger logging the event
42 | * - message - the message being logged
43 | *
44 | * @param {comb.logging.Level|String} [options.level=comb.logging.Level.INFO] the logging level of this appender
45 | * Note: the level can be different from the logger in the case that you want a particular logger
46 | * to only log particular event of a level. For example an appender that only logs errors. BEWARE that if the
47 | * appenders level is lower than the logger is will not recieve any messages.
48 | *
49 | * @param {String} [options.file="./log.json"] the file to log events to.
50 | * @param {String} [options.encoding="utf8"] the encoding of the file.
51 | *
52 | * @ignoreCode
53 | */
54 | FileAppender.extend({
55 | instance:{
56 |
57 | constructor:function (options) {
58 | options = options || {};
59 | this.name = options.name || "JSONAppender";
60 | this.__count = 0;
61 | this.__file = options.file || "./log.json";
62 | this.__encoding = options.encoding || "utf8";
63 | this.__writeStream = options.writeStream || fs.createWriteStream(this.__file, { flags:"w", encoding:this.__encoding});
64 | this.__writeStream.write("[\n");
65 | this.level = options.level;
66 | //explicit overwrite of patter
67 | this.__pattern = '{"timestamp" : "{timeStamp}", "level" : "{levelName}", "name" : "{name}", "message" : "{message}"}';
68 | base.listenForExit(base.hitch(this, "__onExit"));
69 | },
70 |
71 | append:function (event) {
72 | if (this._canAppend(event)) {
73 | event.message = event.message.replace(/\n+/g, "\\n");
74 | var message = (this.__count ? ",\n" : "\n") + format(this.__pattern, event);
75 | this.__writeStream.write(message);
76 | this.__count++;
77 | }
78 | },
79 |
80 |
81 | __onExit:function () {
82 | this.__writeStream.write("]");
83 | this._super(arguments);
84 | }
85 | }
86 | }).registerType("JSONAppender").as(module);
--------------------------------------------------------------------------------
/lib/logging/level.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var define = require("../define.js").define, base = require("../base");
3 |
4 | var LEVELS = {
5 | ALL: -100000,
6 | DEBUG: 1,
7 | TRACE: 2,
8 | INFO: 3,
9 | WARN: 4,
10 | ERROR: 5,
11 | FATAL: 6,
12 | OFF: 100000
13 | };
14 |
15 | var LEVELS_REVERSE = {
16 | "-100000": "ALL",
17 | "1": "DEBUG",
18 | "2": "TRACE",
19 | "3": "INFO",
20 | "4": "WARN",
21 | "5": "ERROR",
22 | "6": "FATAL",
23 | "100000": "OFF"
24 | };
25 |
26 | /**
27 | * @class Level class used to describe logging levels. The levels determine what types of events are logged to the appenders
28 | * for example the if Level.ALL is used then all event will be logged, however if Level.INFO was used then ONLY
29 | * INFO, WARN, ERROR, and FATAL events will be logged. To turn off logging for a logger use Level.OFF.
30 | *
31 | * Not typically instantiated directly, but through staticly defined levels
32 | * @example
33 | * //Levels in ascending order
34 | * comb.logging.Level.ALL
35 | * comb.logging.Level.DEBUG
36 | * comb.logging.Level.TRACE
37 | * comb.logging.Level.INFO
38 | * comb.logging.Level.WARN
39 | * comb.logging.Level.ERROR
40 | * comb.logging.Level.FATAL
41 | * comb.logging.Level.OFF
42 | *
43 | * //or
44 | * Level.getLevel("INFO");
45 | *
46 | * @name Level
47 | * @memberOf comb.logging
48 | *
49 | * @property {Number} level the numerical representation of this level.
50 | * @property {String} name the name of level.
51 | * @ignoreCode
52 | */
53 | var Level = (exports = module.exports = define(null, {
54 | instance: {
55 | /**@lends comb.logging.Level.prototype*/
56 |
57 | constructor: function (level, name) {
58 | this.level = level;
59 | this.name = name;
60 | },
61 |
62 | /**
63 | * Determing if this level is >= another level
64 | * @param {comb.logging.Level} level the level to test against
65 | *
66 | * @returns {Boolean} true if this is >= false otherwise.
67 | */
68 | isGreaterOrEqualToo: function (level) {
69 | var ret = false;
70 | if (level && base.isNumber(level.level)) {
71 | if (this.level >= level.level) {
72 | ret = true;
73 | }
74 | }
75 | return ret;
76 | },
77 |
78 | /**
79 | * Determing if this level is equal to another level based off of the numerical rank.
80 | *
81 | * @param {comb.logging.Level} level the level to compare
82 | *
83 | * @returns {Boolean} true if this is equal to that false otherwise.
84 | */
85 | equals: function (level) {
86 | return level.level === this.level;
87 | }
88 | },
89 | static: {
90 | /**@lends comb.logging.Level*/
91 |
92 | /**
93 | * Converts a numerical or string representation of a level, if a default level is provided,
94 | * then if a level cannot be determined then the default level is used.
95 | *
96 | * @param {Number|String|comb.logging.Level} level the level to try to convert
97 | * @param {comb.logging.Level} [defaultLevel] default level to use if one cannot be determined,
98 | *
99 | * @returns {comb.logging.Level|null} returns a level if one can be determined null otherwise.
100 | */
101 | toLevel: function (level, defaultLevel) {
102 | var ret = null;
103 | var args = base.argsToArray(arguments);
104 | if (args.length === 1) {
105 | level = args[0];
106 | if (base.isNumber(level)) {
107 | var strLevel = LEVELS_REVERSE[level];
108 | ret = Level[strLevel];
109 | } else if (base.isString(level)) {
110 | ret = Level[level.toUpperCase()];
111 | } else {
112 | ret = level;
113 | }
114 | } else {
115 | ret = (Level.toLevel(args[0]) || args[1]);
116 | }
117 | return ret;
118 | },
119 |
120 | /**
121 | * Adds a new level to the Level object.
122 | *
123 | * @example
124 | *
125 | * logger = Logger.getLogger("my.logger");
126 | *
127 | * //create the custom level
128 | * Level.addLevel("custom_Level", 20);
129 | *
130 | * //now set the level on a logger
131 | * logger.level = Level.CUSTOM_LEVEL;
132 | *
133 | * @param {string} label the label of the level, Note: the label will be coverted to uppercase.
134 | * @param {number} level the level of the level
135 | *
136 | * @return {undefined|comb.logging.Level} the level that was created.
137 | *
138 | */
139 | addLevel: function (label, level) {
140 | var ret;
141 | if (base.isString(label) && base.isNumber(level)) {
142 | label = label.toUpperCase();
143 | LEVELS_REVERSE[level] = label;
144 | LEVELS[label] = level;
145 | ret = (this[label] = new Level(level, label));
146 | }
147 | return ret;
148 | },
149 |
150 | /**
151 | * Level to allow logging of all events.
152 | */
153 | ALL: null,
154 | /**
155 | * Logs only events debug or greater.
156 | */
157 | DEBUG: null,
158 | /**
159 | * Like debug but provides a finer level of detail
160 | */
161 | TRACE: null,
162 | /**
163 | * Only info, or error related events
164 | */
165 | INFO: null,
166 | /**
167 | * Only warn or error related events
168 | */
169 | WARN: null,
170 | /**
171 | * Error or fatal events
172 | */
173 | ERROR: null,
174 | /**
175 | * Only fatal events
176 | */
177 | FATAL: null,
178 | /**
179 | * No events will be logged.
180 | */
181 | OFF: null
182 |
183 | }
184 | }));
185 |
186 | for (var i in LEVELS_REVERSE) {
187 | Level[LEVELS_REVERSE[i]] = new Level(parseInt(i, 10), LEVELS_REVERSE[i]);
188 | }
--------------------------------------------------------------------------------
/lib/plugins/Broadcaster.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var func = require("../base/functions"),
3 | define = require("../define").define;
4 |
5 |
6 | var Broadcaster = define(null, {
7 | instance: {
8 | /** @lends comb.plugins.Broadcaster.prototype */
9 | /**
10 | * Plugin to allow a class to easily broadcast events
11 | *
12 | * @example
13 | *
14 | * var Mammal = define(comb.plugins.Broadcaster, {
15 | * instance : {
16 | *
17 | * constructor: function(options) {
18 | * options = options || {};
19 | * this._super(arguments);
20 | * this._type = options.type || "mammal";
21 | * },
22 | *
23 | * speak : function() {
24 | * var str = "A mammal of type " + this._type + " sounds like";
25 | * this.broadcast("speak", str);
26 | * this.onSpeak(str);
27 | * return str;
28 | * },
29 | *
30 | * onSpeak : function(){}
31 | * }
32 | * });
33 | *
34 | *
35 | * var m = new Mammal({color : "gold"});
36 | * m.listen("speak", function(str){
37 | * //called back from the broadcast event
38 | * console.log(str);
39 | * });
40 | * m.speak();
41 | *
42 | * @constructs
43 | */
44 | constructor: function () {
45 | this.__listeners = {};
46 | },
47 |
48 | /**
49 | * Broadcasts an event from an object
50 | *
51 | * @param name the name of the event to broadcast
52 | * @param {Object|String|Function|Date|Number} [args] variable number of arguments to pass to listeners, can be anything
53 | */
54 | broadcast: function (topic, args) {
55 | args = Array.prototype.slice.call(arguments, 0);
56 | topic = args.shift();
57 | if (topic && topic in this.__listeners) {
58 | var list = this.__listeners[topic], i = list.length - 1;
59 | while (i >= 0) {
60 | list[i--].cb.apply(this, args);
61 | }
62 | }
63 | },
64 |
65 | /**
66 | * Listens to a broadcasted event
67 | * Simimlar to {@link comb.listen}
68 | *
69 | * @param {String} topic the topic to listen to
70 | * @param {Function} callback the function to callback on event publish
71 | *
72 | * @returns {Array} handle to disconnect a topic
73 | */
74 | listen: function (topic, callback) {
75 | if (!func.isFunction(callback)) {
76 | throw new Error("callback must be a function");
77 | }
78 | var handle = {
79 | topic: topic,
80 | cb: callback
81 | };
82 | var list = this.__listeners[topic];
83 | if (!list) {
84 | list = (this.__listeners[topic] = [handle]);
85 | handle.pos = 0;
86 | } else {
87 | handle.pos = list.push(handle);
88 | }
89 | return handle;
90 | },
91 |
92 | /**
93 | * Disconnects a listener
94 | * Similar to {@link comb.unListen}
95 | *
96 | * @param handle disconnect a handle returned from Broadcaster.listen
97 | */
98 | unListen: function (handle) {
99 | if (handle) {
100 | var topic = handle.topic;
101 | if (topic in this.__listeners) {
102 | var listeners = this.__listeners, list = listeners[topic];
103 | if (list) {
104 | for (var i = list.length - 1; i >= 0; i--) {
105 | if (list[i] === handle) {
106 | list.splice(i, 1);
107 | break;
108 | }
109 | }
110 | }
111 | }
112 | }
113 | }
114 | }
115 | });
116 |
117 | exports = module.exports = Broadcaster;
--------------------------------------------------------------------------------
/lib/plugins/index.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var comb = exports;
3 | /**@namespace plugins for classes using {@link comb.define}*/
4 | comb.plugins = {
5 | Broadcaster : require("./Broadcaster"),
6 | Middleware : require("./Middleware")
7 | };
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "comb",
3 | "description": "A framework for node",
4 | "version": "2.0.0",
5 | "keywords": [
6 | "OO",
7 | "Object Oriented",
8 | "Collections",
9 | "Tree",
10 | "HashTable",
11 | "Pool",
12 | "Logging",
13 | "Promise",
14 | "Promises",
15 | "Proxy"
16 | ],
17 | "repository": {
18 | "type": "git",
19 | "url": "git@github.com:C2FO/comb.git"
20 | },
21 | "homepage": "http://c2fo.github.com/comb/",
22 | "author": "C2FO (http://c2fo.github.com)",
23 | "main": "index.js",
24 | "directories": {
25 | "lib": "lib"
26 | },
27 | "devDependencies": {
28 | "coveralls": "^2.11.4",
29 | "grunt": "^0.4.5",
30 | "grunt-contrib-jshint": "^0.11.3",
31 | "grunt-exec": "^0.4.6",
32 | "grunt-it": "^1.0.0",
33 | "istanbul": "^0.4.1",
34 | "it": "^1.1.0",
35 | "jit-grunt": "^0.9.1",
36 | "time-grunt": "^1.2.2"
37 | },
38 | "scripts": {
39 | "test": "grunt test"
40 | },
41 | "engines": {
42 | "node": ">= 10.0.0"
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/test/base.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require("it"),
3 | assert = require("assert"),
4 | comb = require("../index");
5 |
6 | it.describe("comb", function(it){
7 | it.should("define a plugin", function(){
8 | comb.definePlugin({a : true});
9 | assert.isTrue(comb.a);
10 | });
11 | }).as(module);
--------------------------------------------------------------------------------
/test/base/broadcast.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | define = comb.define,
6 | hitch = comb.hitch,
7 | Broadcaster = comb;
8 |
9 |
10 | it.describe("comb/base/broadcast.js", function (it) {
11 |
12 | //Super of other classes
13 | var Mammal = define(null, {
14 | instance: {
15 |
16 | constructor: function (options) {
17 | options = options || {};
18 | this._super(arguments);
19 | this._type = options.type || "mammal";
20 | },
21 |
22 | speak: function () {
23 | var str = "A mammal of type " + this._type + " sounds like";
24 | comb.broadcast("speak", str);
25 | this.onSpeak(str);
26 | return str;
27 | },
28 |
29 | onSpeak: function () {
30 |
31 | }
32 | }
33 | });
34 |
35 |
36 | it.should("#listen", function (next) {
37 | var m = new Mammal({color: "gold"}), h;
38 | h = comb.listen("speak", hitch(this, function (str) {
39 | assert.equal(str, "A mammal of type mammal sounds like");
40 | comb.unListen(h);
41 | next();
42 | }));
43 | m.speak();
44 | });
45 |
46 | it.should("#unlisten", function (next) {
47 | var m = new Mammal({color: "gold"});
48 | var han = comb.listen("speak", next);
49 | comb.unListen(han);
50 | comb.listen("speak", hitch(this, function () {
51 | next();
52 | }));
53 | m.speak();
54 | });
55 |
56 | it.should("#connect", function (next) {
57 | var m = new Mammal({color: "gold"}), h;
58 | h = comb.connect(m, "speak", hitch(this, function (str) {
59 | comb.disconnect(h);
60 | next();
61 | }));
62 | m.speak();
63 | });
64 |
65 | it.should("#disconnect", function (next) {
66 | var m = new Mammal({color: "gold"});
67 | var han = comb.connect(m, "speak", next);
68 | comb.disconnect(han);
69 | comb.connect(m, "speak", hitch(this, function () {
70 | next();
71 | }));
72 | m.speak();
73 | });
74 |
75 | it.should("throw an error on #connect if the function does not exist", function () {
76 | var m = new Mammal({color: "gold"});
77 | assert.throws(function () {
78 | comb.connect(m, "someMethod", function () {
79 | });
80 | });
81 | });
82 |
83 | it.should("throw an error on #disconnect if an invalid handler is passed in", function () {
84 | assert.throws(function () {
85 | comb.disconnect();
86 | });
87 |
88 | assert.throws(function () {
89 | comb.disconnect([comb, "someMethod", function () {
90 | }]);
91 | });
92 | });
93 |
94 | }).as(module);
95 |
96 |
97 |
98 |
99 |
100 |
--------------------------------------------------------------------------------
/test/base/inflections.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index");
5 |
6 | it.describe("comb/base/inflections.js", function (it) {
7 | var INFLECTIONS = {
8 | test: "tests",
9 | ax: "axes",
10 | testis: "testes",
11 | octopus: "octopuses",
12 | virus: "viruses",
13 | alias: "aliases",
14 | status: "statuses",
15 | bus: "buses",
16 | buffalo: "buffaloes",
17 | tomato: "tomatoes",
18 | datum: "data",
19 | bacterium: "bacteria",
20 | analysis: "analyses",
21 | basis: "bases",
22 | diagnosis: "diagnoses",
23 | parenthesis: "parentheses",
24 | prognosis: "prognoses",
25 | synopsis: "synopses",
26 | thesis: "theses",
27 | wife: "wives",
28 | giraffe: "giraffes",
29 | self: "selves",
30 | dwarf: "dwarves",
31 | hive: "hives",
32 | fly: "flies",
33 | buy: "buys",
34 | soliloquy: "soliloquies",
35 | day: "days",
36 | attorney: "attorneys",
37 | boy: "boys",
38 | hoax: "hoaxes",
39 | lunch: "lunches",
40 | princess: "princesses",
41 | matrix: "matrices",
42 | vertex: "vertices",
43 | index: "indices",
44 | mouse: "mice",
45 | louse: "lice",
46 | quiz: "quizzes",
47 | motive: "motives",
48 | movie: "movies",
49 | series: "series",
50 | crisis: "crises",
51 | person: "people",
52 | man: "men",
53 | woman: "women",
54 | child: "children",
55 | sex: "sexes",
56 | move: "moves"
57 | };
58 | //Super of other classes
59 |
60 | it.should("camelize correctly", function () {
61 | assert.isNull(comb.camelize(null));
62 | assert.isUndefined(comb.camelize());
63 | assert.equal(comb.camelize("hello_world"), "helloWorld");
64 | assert.equal(comb.camelize("column_name"), "columnName");
65 | assert.equal(comb.camelize("columnName"), "columnName");
66 |
67 | assert.equal(comb("hello_world").camelize(), "helloWorld");
68 | assert.equal(comb("column_name").camelize(), "columnName");
69 | assert.equal(comb("columnName").camelize(), "columnName");
70 | });
71 |
72 |
73 | it.should("underscore correctly", function () {
74 | assert.isNull(comb.underscore(null));
75 | assert.isUndefined(comb.underscore());
76 | assert.equal(comb.underscore("helloWorld"), "hello_world");
77 | assert.equal(comb.underscore("helloWorld1"), "hello_world_1");
78 | assert.equal(comb.underscore("1HelloWorld"), "1_hello_world");
79 | assert.equal(comb.underscore("column_name"), "column_name");
80 | assert.equal(comb.underscore("columnName"), "column_name");
81 |
82 | assert.equal(comb("helloWorld").underscore(), "hello_world");
83 | assert.equal(comb("helloWorld1").underscore(), "hello_world_1");
84 | assert.equal(comb("1HelloWorld").underscore(), "1_hello_world");
85 | assert.equal(comb("column_name").underscore(), "column_name");
86 | assert.equal(comb("columnName").underscore(), "column_name");
87 | });
88 |
89 | it.should("classify correctly", function () {
90 | assert.isNull(comb.classify(null));
91 | assert.isUndefined(comb.classify());
92 | assert.equal(comb.classify('egg_and_hams'), "eggAndHam");
93 | assert.equal(comb.classify('post'), "post");
94 | assert.equal(comb.classify('schema.post'), "post");
95 |
96 | assert.equal(comb('egg_and_hams').classify(), "eggAndHam");
97 | assert.equal(comb('post').classify(), "post");
98 | assert.equal(comb('schema.post').classify(), "post");
99 | });
100 |
101 |
102 | it.should("singularize correctly", function () {
103 | assert.isNull(comb.singularize(null));
104 | assert.isUndefined(comb.singularize());
105 | for (var i in INFLECTIONS) {
106 | assert.equal(comb.singularize(INFLECTIONS[i]), i);
107 | assert.equal(comb(INFLECTIONS[i]).singularize(), i);
108 | }
109 | });
110 |
111 | it.should("pluralize correctly", function () {
112 | assert.isNull(comb.pluralize(null));
113 | assert.isUndefined(comb.pluralize());
114 | for (var i in INFLECTIONS) {
115 | assert.equal(comb.pluralize(i), INFLECTIONS[i]);
116 | assert.equal(comb(i).pluralize(), INFLECTIONS[i]);
117 | }
118 | });
119 |
120 |
121 | }).as(module);
122 |
123 |
--------------------------------------------------------------------------------
/test/base/misc.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index");
5 |
6 | it.describe("comb/base/misc.js", function (it) {
7 | //Super of other classes
8 | it.should("#isBoolean", function () {
9 | //This is true because they inherit from eachother!
10 | assert.isTrue(comb.isBoolean(true));
11 | assert.isTrue(comb(true).isBoolean());
12 | assert.isFalse(comb.isBoolean(function () {
13 | }));
14 |
15 | assert.isFalse(comb(function () {
16 | }).isBoolean());
17 |
18 | assert.isFalse(comb.isBoolean("hello"));
19 | assert.isFalse(comb("hello").isBoolean());
20 | assert.isFalse(comb.isBoolean({}));
21 | assert.isFalse(comb({}).isBoolean());
22 | assert.isFalse(comb(new Date()).isBoolean());
23 | assert.isFalse(comb(1).isBoolean());
24 | });
25 |
26 | it.should("#isArguments", function () {
27 | assert.isTrue(comb.isArguments(arguments));
28 | assert.isTrue(comb(arguments).isArguments());
29 | assert.isFalse(comb.isArguments(function () {
30 | }));
31 |
32 | assert.isFalse(comb(function () {
33 | }).isArguments());
34 | assert.isFalse(comb.isArguments("hello"));
35 | assert.isFalse(comb("hello").isArguments());
36 | assert.isFalse(comb({}).isArguments());
37 | assert.isFalse(comb(new Date()).isArguments());
38 | assert.isFalse(comb(1).isArguments());
39 | });
40 |
41 | it.should("#isUndefined", function () {
42 | assert.isTrue(comb.isUndefined(undefined));
43 | assert.isFalse(comb.isUndefined(null));
44 | assert.isFalse(comb.isUndefined(true));
45 | assert.isFalse(comb(true).isUndefined());
46 | assert.isFalse(comb.isUndefined(function () {
47 | }));
48 | assert.isFalse(comb(function () {
49 | }).isUndefined());
50 | assert.isFalse(comb("hello").isUndefined());
51 | assert.isFalse(comb({}).isUndefined());
52 | assert.isFalse(comb(new Date()).isUndefined());
53 | assert.isFalse(comb(1).isUndefined());
54 | });
55 |
56 | it.should("#isNull", function () {
57 | //This is true because they inherit from eachother!
58 | assert.isTrue(comb.isNull(null));
59 | assert.isFalse(comb.isNull(undefined));
60 | assert.isFalse(comb.isNull(true));
61 | assert.isFalse(comb(true).isNull());
62 | assert.isFalse(comb.isNull(function () {
63 | }));
64 | assert.isFalse(comb(function () {
65 | }).isNull());
66 | assert.isFalse(comb("hello").isNull());
67 | assert.isFalse(comb({}).isNull());
68 | assert.isFalse(comb(new Date()).isNull());
69 | assert.isFalse(comb(1).isNull());
70 | });
71 |
72 | it.should("#isDefined", function () {
73 | //This is true because they inherit from eachother!
74 | assert.isTrue(comb.isDefined(null));
75 | assert.isFalse(comb.isDefined(undefined));
76 | assert.isTrue(comb.isDefined(true));
77 | assert.isTrue(comb(true).isDefined());
78 | assert.isTrue(comb.isDefined(function () {
79 | }));
80 | assert.isTrue(comb(function () {
81 | }).isDefined());
82 | assert.isTrue(comb("hello").isDefined());
83 | assert.isTrue(comb({}).isDefined());
84 | assert.isTrue(comb(new Date()).isDefined());
85 | assert.isTrue(comb(1).isDefined());
86 | });
87 |
88 | it.should("#isInstanceOf", function () {
89 | /*jshint -W053 */
90 | //This is true because they inherit from eachother!
91 | assert.isTrue(comb.isInstanceOf(new Date(), Date));
92 | assert.isTrue(comb(new Date()).isInstanceOf(Date));
93 | assert.isTrue(comb(new Number(1)).isInstanceOf(Number));
94 | assert.isTrue(comb(new String(1)).isInstanceOf(String));
95 | assert.isFalse(comb.isInstanceOf(undefined, String));
96 | assert.isFalse(comb.isInstanceOf(undefined, 1));
97 | });
98 |
99 | it.should("convert arumgents to array", function () {
100 |
101 | (function () {
102 | assert.deepEqual(comb.argsToArray(arguments), [1, 2, 3]);
103 | assert.deepEqual(comb(arguments).toArray(), [1, 2, 3]);
104 | assert.deepEqual(comb.argsToArray(arguments, 1), [2, 3]);
105 | assert.deepEqual(comb(arguments).toArray(1), [2, 3]);
106 | })(1, 2, 3);
107 |
108 | });
109 | }).as(module);
110 |
111 |
--------------------------------------------------------------------------------
/test/base/regexp.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index");
5 |
6 |
7 | it.describe("comb/base/regexp.js", function (it) {
8 | //Super of other classes
9 |
10 | it.should("escape it properly", function () {
11 | var chars = [".", "$", "?", "*", "|", "{", "}", "(", ")", "[", "]", "\\", "/", "+", "^"];
12 | chars.forEach(function (c) {
13 | assert.equal(comb.regexp.escapeString(c), "\\" + c);
14 | assert.equal(comb(c).escape(), "\\" + c);
15 | });
16 | chars.forEach(function (c) {
17 | assert.equal(comb(c).escape([c]), c);
18 | });
19 | });
20 |
21 |
22 | it.should("determine if something is a RegExp", function () {
23 | assert.isTrue(comb.isRexExp(/a/));
24 | assert.isTrue(comb.isRexExp(new RegExp("a")));
25 | assert.isFalse(comb.isRexExp());
26 | assert.isFalse(comb.isRexExp(""));
27 | assert.isFalse(comb.isRexExp(1));
28 | assert.isFalse(comb.isRexExp(false));
29 | assert.isFalse(comb.isRexExp(true));
30 |
31 | assert.isTrue(comb(/a/).isRegExp());
32 | assert.isTrue(comb(new RegExp("a")).isRegExp());
33 | assert.isFalse(comb("").isRegExp());
34 | assert.isFalse(comb(1).isRegExp());
35 | assert.isFalse(comb(false).isRegExp());
36 | assert.isFalse(comb(true).isRegExp());
37 | });
38 |
39 |
40 | }).as(module);
--------------------------------------------------------------------------------
/test/collections/AVLTree.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | helper = require("./treeTest.helper.js"),
6 | Mammal = helper.Mammal,
7 | AVLTree = comb.collections.AVLTree;
8 |
9 |
10 | it.describe("comb.collections.AVLTree", function (it) {
11 |
12 | var words = ["c", "ca", "b", "ba", "bb", "a", "aa", "ab", "z", "d", "f", "h", "i", "ee", "ff", "hi", "j", "ajk"];
13 | var wordsInOrder = ['a', 'aa', 'ab', 'ajk', 'b', 'ba', 'bb', 'c', 'ca', 'd', 'ee', 'f', 'ff', 'h', 'hi', 'i', 'j', 'z'];
14 | var wordsPreOrder = ['ba', 'aa', 'a', 'ajk', 'ab', 'b', 'h', 'd', 'c', 'bb', 'ca', 'f', 'ee', 'ff', 'i', 'hi', 'z', 'j'];
15 | var wordsPostOrder = ['a', 'ab', 'b', 'ajk', 'aa', 'bb', 'ca', 'c', 'ee', 'ff', 'f', 'd', 'hi', 'j', 'z', 'i', 'h', 'ba'];
16 |
17 |
18 | var mammals = [
19 | new Mammal({type: "bird"}),
20 | new Mammal({type: "dog"}),
21 | new Mammal({type: "rat"}),
22 | new Mammal({type: "zebra"}),
23 | new Mammal({type: "mouse"}),
24 | new Mammal({type: "horse"}),
25 | new Mammal({type: "squirrel"}),
26 | new Mammal({type: "groundhog"})
27 | ],
28 |
29 | mammalsInOrder = [
30 | new Mammal({type: "bird"}),
31 | new Mammal({type: "dog"}),
32 | new Mammal({type: "groundhog"}),
33 | new Mammal({type: "horse"}),
34 | new Mammal({type: "mouse"}),
35 | new Mammal({type: "rat"}),
36 | new Mammal({type: "squirrel"}),
37 | new Mammal({type: "zebra"})
38 | ],
39 |
40 | mammalsPreOrder = [
41 | new Mammal({type: "mouse"}),
42 | new Mammal({type: "dog"}),
43 | new Mammal({type: "bird"}),
44 | new Mammal({type: "horse"}),
45 | new Mammal({type: "groundhog"}),
46 | new Mammal({type: "squirrel"}),
47 | new Mammal({type: "rat"}),
48 | new Mammal({type: "zebra"})
49 |
50 | ],
51 |
52 | mammalsPostOrder = [
53 | new Mammal({type: "bird"}),
54 | new Mammal({type: "groundhog"}),
55 | new Mammal({type: "horse"}),
56 | new Mammal({type: "dog"}),
57 | new Mammal({type: "rat"}),
58 | new Mammal({type: "zebra"}),
59 | new Mammal({type: "squirrel"}),
60 | new Mammal({type: "mouse"})
61 |
62 | ];
63 | var orderedMammals = [
64 | [AVLTree.IN_ORDER, mammalsInOrder],
65 | [AVLTree.PRE_ORDER, mammalsPreOrder],
66 | [AVLTree.POST_ORDER, mammalsPostOrder]
67 | ];
68 |
69 |
70 | var expectedOutput = "\t\t\t\t~\n\t\t\tz:-1\n\n\t\t\t\t\t~\n\t\t\t\tj:0\n\n\t\t\t\t\t~\n\t\ti:1\n\n\t\t\t\t~\n\t\t\t" +
71 | "hi:0\n\n\t\t\t\t~\n\th:0\n\n\t\t\t\t\t~\n\t\t\t\tff:0\n\n\t\t\t\t\t~\n\t\t\tf:0\n\n\t\t\t\t\t~\n\t\t\t\t" +
72 | "ee:0\n\n\t\t\t\t\t~\n\t\td:0\n\n\t\t\t\t\t~\n\t\t\t\tca:0\n\n\t\t\t\t\t~\n\t\t\tc:0\n\n\t\t\t\t\t~\n\t\t\t\t" +
73 | "bb:0\n\n\t\t\t\t\t~\nba:1\n\n\t\t\t\t~\n\t\t\tb:0\n\n\t\t\t\t~\n\t\tajk:0\n\n\t\t\t\t~\n\t\t\tab:0\n\n\t\t\t\t~\n\t" +
74 | "aa:1\n\n\t\t\t~\n\t\ta:0\n\n\t\t\t~";
75 |
76 | var orderedWords = [
77 | [AVLTree.IN_ORDER, wordsInOrder],
78 | [AVLTree.PRE_ORDER, wordsPreOrder],
79 | [AVLTree.POST_ORDER, wordsPostOrder]
80 | ];
81 |
82 |
83 | helper.setup(
84 | it,
85 | AVLTree,
86 | words,
87 | orderedWords,
88 | mammals,
89 | orderedMammals,
90 | expectedOutput);
91 |
92 | }).as(module);
--------------------------------------------------------------------------------
/test/collections/AnderssonTree.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | helper = require("./treeTest.helper.js"),
6 | Mammal = helper.Mammal,
7 | AnderssonTree = comb.collections.AnderssonTree;
8 |
9 |
10 | it.describe("comb.collections.AnderssonTree", function (it) {
11 | var words = ["c", "ca", "b", "ba", "bb", "a", "aa", "ab", "z", "d", "f", "h", "i", "ee", "ff", "hi", "j", "ajk"];
12 | var wordsInOrder = ['a', 'aa', 'ab', 'ajk', 'b', 'ba', 'bb', 'c', 'ca', 'd', 'ee', 'f', 'ff', 'h', 'hi', 'i', 'j', 'z'];
13 | var wordsPreOrder = ['d', 'ba', 'aa', 'a', 'ajk', 'ab', 'b', 'c', 'bb', 'ca', 'h', 'f', 'ee', 'ff', 'i', 'hi', 'j', 'z'];
14 | var wordsPostOrder = ['a', 'ab', 'b', 'ajk', 'aa', 'bb', 'ca', 'c', 'ba', 'ee', 'ff', 'f', 'hi', 'z', 'j', 'i', 'h', 'd'];
15 |
16 |
17 | var mammals = [
18 | new Mammal({type: "bird"}),
19 | new Mammal({type: "dog"}),
20 | new Mammal({type: "rat"}),
21 | new Mammal({type: "zebra"}),
22 | new Mammal({type: "mouse"}),
23 | new Mammal({type: "horse"}),
24 | new Mammal({type: "squirrel"}),
25 | new Mammal({type: "groundhog"})
26 | ],
27 |
28 | mammalsInOrder = [
29 | new Mammal({type: "bird"}),
30 | new Mammal({type: "dog"}),
31 | new Mammal({type: "groundhog"}),
32 | new Mammal({type: "horse"}),
33 | new Mammal({type: "mouse"}),
34 | new Mammal({type: "rat"}),
35 | new Mammal({type: "squirrel"}),
36 | new Mammal({type: "zebra"})
37 | ],
38 |
39 | mammalsPreOrder = [
40 | new Mammal({type: "horse"}),
41 | new Mammal({type: "dog"}),
42 | new Mammal({type: "bird"}),
43 | new Mammal({type: "groundhog"}),
44 | new Mammal({type: "rat"}),
45 | new Mammal({type: "mouse"}),
46 | new Mammal({type: "squirrel"}),
47 | new Mammal({type: "zebra"})
48 |
49 | ],
50 |
51 | mammalsPostOrder = [
52 | new Mammal({type: "bird"}),
53 | new Mammal({type: "groundhog"}),
54 | new Mammal({type: "dog"}),
55 | new Mammal({type: "mouse"}),
56 | new Mammal({type: "zebra"}),
57 | new Mammal({type: "squirrel"}),
58 | new Mammal({type: "rat"}),
59 | new Mammal({type: "horse"})
60 | ];
61 | var orderedMammals = [
62 | [AnderssonTree.IN_ORDER, mammalsInOrder],
63 | [AnderssonTree.PRE_ORDER, mammalsPreOrder],
64 | [AnderssonTree.POST_ORDER, mammalsPostOrder]
65 | ];
66 |
67 |
68 | var orderedWords = [
69 | [AnderssonTree.IN_ORDER, wordsInOrder],
70 | [AnderssonTree.PRE_ORDER, wordsPreOrder],
71 | [AnderssonTree.POST_ORDER, wordsPostOrder]
72 | ];
73 | helper.setup(
74 | it,
75 | AnderssonTree,
76 | words,
77 | orderedWords,
78 | mammals,
79 | orderedMammals,
80 | "\t\t\t\t\t~\n\t\t\t\tz:1\n\n\t\t\t\t\t~\n\t\t\tj:1\n\n\t\t\t\t~\n\t\ti:2\n\n\t\t\t\t~\n\t\t\thi:1\n\n\t\t\t\t" +
81 | "~\n\th:3\n\n\t\t\t\t~\n\t\t\tff:1\n\n\t\t\t\t~\n\t\tf:2\n\n\t\t\t\t~\n\t\t\tee:1\n\n\t\t\t\t" +
82 | "~\nd:4\n\n\t\t\t\t~\n\t\t\tca:1\n\n\t\t\t\t~\n\t\tc:2\n\n\t\t\t\t~\n\t\t\tbb:1\n\n\t\t\t\t" +
83 | "~\n\tba:3\n\n\t\t\t\t\t~\n\t\t\t\tb:1\n\n\t\t\t\t\t~\n\t\t\tajk:2\n\n\t\t\t\t\t~\n\t\t\t\t" +
84 | "ab:1\n\n\t\t\t\t\t~\n\t\taa:2\n\n\t\t\t\t~\n\t\t\ta:1\n\n\t\t\t\t~");
85 | }).as(module);
86 |
--------------------------------------------------------------------------------
/test/collections/BinaryTree.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | helper = require("./treeTest.helper.js"),
6 | Mammal = helper.Mammal,
7 | BinaryTree = comb.collections.BinaryTree;
8 |
9 |
10 | it.describe("comb.collections.BinaryTree", function (it) {
11 |
12 | var words = ["c", "ca", "b", "ba", "bb", "a", "a", "aa", "ab", "z", "d", "f", "h", "i", "ee", "ff", "hi", "j", "ajk"];
13 | var wordsInOrder = ['a', 'aa', 'ab', 'ajk', 'b', 'ba', 'bb', 'c', 'ca', 'd', 'ee', 'f', 'ff', 'h', 'hi', 'i', 'j', 'z'];
14 | var wordsPreOrder = ["c", "b", "a", "aa", "ab", "ajk", "ba", "bb", "ca", "z", "d", "f", "ee", "h", "ff", "i", "hi", "j"];
15 | var wordsPostOrder = ["ajk", "ab", "aa", "a", "bb", "ba", "b", "ee", "ff", "hi", "j", "i", "h", "f", "d", "z", "ca", "c"];
16 |
17 | var mammals = [
18 | new Mammal({type: "bird"}),
19 | new Mammal({type: "dog"}),
20 | new Mammal({type: "rat"}),
21 | new Mammal({type: "mouse"}),
22 | new Mammal({type: "zebra"}),
23 | new Mammal({type: "horse"}),
24 | new Mammal({type: "squirrel"}),
25 | new Mammal({type: "groundhog"})
26 | ],
27 |
28 | mammalsInOrder = [
29 | new Mammal({type: "bird"}),
30 | new Mammal({type: "dog"}),
31 | new Mammal({type: "groundhog"}),
32 | new Mammal({type: "horse"}),
33 | new Mammal({type: "mouse"}),
34 | new Mammal({type: "rat"}),
35 | new Mammal({type: "squirrel"}),
36 | new Mammal({type: "zebra"})
37 | ],
38 |
39 | mammalsPreOrder = [
40 | new Mammal({type: "bird"}),
41 | new Mammal({type: "dog"}),
42 | new Mammal({type: "rat"}),
43 | new Mammal({type: "mouse"}),
44 | new Mammal({type: "horse"}),
45 | new Mammal({type: "groundhog"}),
46 | new Mammal({type: "zebra"}),
47 | new Mammal({type: "squirrel"})
48 | ],
49 |
50 | mammalsPostOrder = [
51 | new Mammal({type: "groundhog"}),
52 | new Mammal({type: "horse"}),
53 | new Mammal({type: "mouse"}),
54 | new Mammal({type: "squirrel"}),
55 | new Mammal({type: "zebra"}),
56 | new Mammal({type: "rat"}),
57 | new Mammal({type: "dog"}),
58 | new Mammal({type: "bird"})
59 | ];
60 |
61 | var expectedOutput = "\t\t\t~\n\t\tz\n\n\t\t\t\t\t\t\t\t~\n\t\t\t\t\t\t\tj\n\n\t\t\t\t\t\t\t\t~\n\t\t\t\t\t\t" +
62 | "i\n\n\t\t\t\t\t\t\t\t~\n\t\t\t\t\t\t\thi\n\n\t\t\t\t\t\t\t\t~\n\t\t\t\t\th\n\n\t\t\t\t\t\t\t~\n\t\t\t\t\t\t" +
63 | "ff\n\n\t\t\t\t\t\t\t~\n\t\t\t\tf\n\n\t\t\t\t\t\t~\n\t\t\t\t\tee\n\n\t\t\t\t\t\t~\n\t\t\td\n\n\t\t\t\t~\n\t" +
64 | "ca\n\n\t\t~\nc\n\n\t\t\t\t~\n\t\t\tbb\n\n\t\t\t\t~\n\t\tba\n\n\t\t\t~\n\tb\n\n\t\t\t\t\t\t~\n\t\t\t\t\t" +
65 | "ajk\n\n\t\t\t\t\t\t~\n\t\t\t\tab\n\n\t\t\t\t\t~\n\t\t\taa\n\n\t\t\t\t~\n\t\ta\n\n\t\t\t~";
66 | var orderedWords = [
67 | [BinaryTree.IN_ORDER, wordsInOrder],
68 | [BinaryTree.PRE_ORDER, wordsPreOrder],
69 | [BinaryTree.POST_ORDER, wordsPostOrder]
70 | ];
71 | var orderedMammals = [
72 | [BinaryTree.IN_ORDER, mammalsInOrder],
73 | [BinaryTree.PRE_ORDER, mammalsPreOrder],
74 | [BinaryTree.POST_ORDER, mammalsPostOrder]
75 | ];
76 |
77 |
78 | helper.setup(
79 | it,
80 | BinaryTree,
81 | words,
82 | orderedWords,
83 | mammals,
84 | orderedMammals,
85 | expectedOutput);
86 |
87 |
88 | }).as(module);
89 |
90 |
91 |
92 |
--------------------------------------------------------------------------------
/test/collections/Collection.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Collection = comb.collections.Collection;
6 |
7 |
8 | it.describe("comb.collections.Collection", function (it) {
9 |
10 |
11 | var collection = new Collection();
12 | ["concat", "join", "slice", "toString", "indexOf", "lastIndexOf"].forEach(function (m) {
13 | it.describe("#" + m, function (it) {
14 | it.should("be a method", function () {
15 | assert.isFunction(collection[m]);
16 | });
17 |
18 | it.should("throw an error if invoked", function () {
19 | assert.throws(function () {
20 | collection[m]();
21 | });
22 | });
23 | });
24 | });
25 |
26 | }).as(module);
27 |
--------------------------------------------------------------------------------
/test/collections/Heap.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Heap = comb.collections.Heap;
6 |
7 |
8 | it.describe("comb.collections.Heap", function (it) {
9 | var heap = new Heap();
10 |
11 | it.should("throw an error when calling insert and remove methods", function () {
12 | assert.throws(function () {
13 | heap.insert(1, "hello");
14 | });
15 | assert.throws(function () {
16 | heap.__downHeap();
17 | });
18 | });
19 |
20 | it.should("throw an error when using an invalid key", function () {
21 | assert.throws(function () {
22 | heap.insert("1", 2);
23 | });
24 | });
25 |
26 |
27 | }).as(module);
28 |
29 |
--------------------------------------------------------------------------------
/test/collections/Iterable.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Iterable = comb.collections.Iterable;
6 |
7 |
8 | it.describe("comb.collections.Iterable", function (it) {
9 |
10 | var iter = new Iterable();
11 | ["filter", "forEach", "every", "map", "some", "reduce", "reduceRight"].forEach(function (m) {
12 | it.describe("#" + m, function (it) {
13 |
14 | it.should("be a function", function () {
15 | assert.isFunction(iter[m]);
16 | });
17 |
18 | it.should("throw an error if invoked", function () {
19 | assert.throws(function () {
20 | iter[m]();
21 | });
22 | });
23 |
24 | });
25 | });
26 |
27 | }).as(module);
28 |
--------------------------------------------------------------------------------
/test/collections/MaxHeap.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | MaxHeap = comb.collections.MaxHeap;
6 |
7 | it.describe("comb.collections.MaxHeap", function (it) {
8 |
9 | it.should("know its count", function () {
10 | var h = new MaxHeap();
11 | h.insert(0, 'a');
12 | h.insert(1, 'b');
13 | h.insert(2, 'c');
14 | h.insert(3, 'd');
15 | assert.equal(h.count, 4);
16 | h.remove();
17 | assert.equal(h.count, 3);
18 | h.remove();
19 | h.remove();
20 | h.remove();
21 | assert.equal(h.count, 0);
22 | });
23 |
24 | it.should("know its keys", function () {
25 | var h = new MaxHeap();
26 | h.insert(0, 'a');
27 | h.insert(1, 'b');
28 | h.insert(2, 'c');
29 | h.insert(3, 'd');
30 | var keys = h.keys;
31 | for (var i = 0; i < 4; i++) {
32 | assert.isTrue(keys.indexOf(i) !== -1);
33 | }
34 | for (i = 0; i < 4; i++) {
35 | assert.isTrue(h.containsKey(i));
36 | }
37 | assert.isFalse(h.containsKey(4));
38 | });
39 |
40 | it.should("know its values", function () {
41 | var h = new MaxHeap();
42 | h.insert(0, 'a');
43 | h.insert(1, 'b');
44 | h.insert(2, 'c');
45 | h.insert(3, 'd');
46 | var vals = h.values;
47 | assert.isTrue(vals.indexOf("a") !== -1);
48 | assert.isTrue(vals.indexOf("b") !== -1);
49 | assert.isTrue(vals.indexOf("c") !== -1);
50 | assert.isTrue(vals.indexOf("d") !== -1);
51 | assert.isTrue(h.containsValue("a"));
52 | assert.isTrue(h.containsValue("b"));
53 | assert.isTrue(h.containsValue("c"));
54 | assert.isTrue(h.containsValue("d"));
55 | assert.isFalse(h.containsValue("e"));
56 | });
57 |
58 | it.should("remove items ", function () {
59 | var h = new MaxHeap();
60 | h.insert(0, 'a');
61 | h.insert(1, 'b');
62 | h.insert(2, 'c');
63 | h.insert(3, 'd');
64 | assert.isFalse(h.isEmpty);
65 | h.remove();
66 | assert.isFalse(h.isEmpty);
67 | h.remove();
68 | assert.isFalse(h.isEmpty);
69 | h.remove();
70 | assert.isFalse(h.isEmpty);
71 | h.remove();
72 | assert.isTrue(h.isEmpty);
73 | });
74 |
75 | it.should("clear all values", function () {
76 | var h = new MaxHeap();
77 | h.insert(0, 'a');
78 | h.insert(1, 'b');
79 | h.insert(2, 'c');
80 | h.insert(3, 'd');
81 | h.clear();
82 | assert.isTrue(h.isEmpty);
83 | assert.equal(h.count, 0, 'count, should be 4');
84 | });
85 |
86 | it.should("peek in order ", function () {
87 | var h = new MaxHeap();
88 | h.insert(0, 'a');
89 | h.insert(1, 'b');
90 | h.insert(2, 'c');
91 | h.insert(3, 'd');
92 | assert.equal(h.peekKey(), 3);
93 | assert.equal(h.peek(), "d");
94 | h.clear();
95 | assert.isUndefined(h.peek());
96 | assert.isUndefined(h.peekKey());
97 | h = new MaxHeap();
98 | h.insert(1, 'b');
99 | h.insert(3, 'd');
100 | h.insert(0, 'a');
101 | h.insert(2, 'c');
102 | assert.equal(h.peekKey(), 3);
103 | assert.equal(h.peek(), "d");
104 |
105 | });
106 |
107 | it.should("remove elements in order", function () {
108 | var h = new MaxHeap();
109 | h.insert(0, 'a');
110 | h.insert(1, 'b');
111 | h.insert(2, 'c');
112 | h.insert(3, 'd');
113 | assert.equal(h.remove(), "d");
114 | assert.equal(h.remove(), "c");
115 | assert.equal(h.remove(), "b");
116 | assert.equal(h.remove(), "a");
117 | h = new MaxHeap();
118 | h.insert(1, 'b');
119 | h.insert(3, 'd');
120 | h.insert(0, 'a');
121 | h.insert(2, 'c');
122 | assert.equal(h.remove(), "d");
123 | assert.equal(h.remove(), "c");
124 | assert.equal(h.remove(), "b");
125 | assert.equal(h.remove(), "a");
126 |
127 | });
128 |
129 |
130 | it.should("peek as items are inserted ", function () {
131 | var h = new MaxHeap();
132 | h.insert(3, 'c');
133 | assert.equal(h.peek(), 'c');
134 | h.insert(2, 'b');
135 | assert.equal(h.peek(), 'c');
136 | h.insert(1, 'd');
137 | assert.equal(h.peek(), 'c');
138 | h.insert(0, 'a');
139 | assert.equal(h.peek(), 'c');
140 | h.clear();
141 | h.insert(1, 'a');
142 | assert.equal(h.peek(), 'a');
143 | h.insert(3, 'b');
144 | assert.equal(h.peek(), 'b');
145 | h.insert(0, 'c');
146 | assert.equal(h.peek(), 'b');
147 | h.insert(2, 'd');
148 | assert.equal(h.peek(), 'b');
149 | });
150 |
151 | it.should("print", function () {
152 | var h = new MaxHeap();
153 | h.insert(1, 'b');
154 | h.insert(3, 'd');
155 | h.insert(0, 'a');
156 | h.insert(2, 'c');
157 | var res = [];
158 | var orig = console.log;
159 | console.log = function (str) {
160 | res.push(str);
161 | };
162 | h.print();
163 | console.log = orig;
164 | res = res.join("\n");
165 |
166 | var expected = "\t\t~\n\t0 : a\n\n\t\t~\n3 : d\n\n\t\t~\n\t2 : c\n\n\t\t\t~\n\t\t1 : b\n\n\t\t\t~";
167 | assert.equal(res, expected);
168 | });
169 |
170 |
171 | }).as(module);
172 |
173 |
174 |
--------------------------------------------------------------------------------
/test/collections/MinHeap.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | MinHeap = comb.collections.MinHeap;
6 |
7 | it.describe("comb.collections.MinHeap", function (it) {
8 |
9 | it.should("know its count", function () {
10 | var h = new MinHeap();
11 | h.insert(0, 'a');
12 | h.insert(1, 'b');
13 | h.insert(2, 'c');
14 | h.insert(3, 'd');
15 | assert.equal(h.count, 4);
16 | h.remove();
17 | assert.equal(h.count, 3);
18 | h.remove();
19 | h.remove();
20 | h.remove();
21 | assert.equal(h.count, 0);
22 | });
23 |
24 | it.should("know its keys", function () {
25 | var h = new MinHeap();
26 | h.insert(0, 'a');
27 | h.insert(1, 'b');
28 | h.insert(2, 'c');
29 | h.insert(3, 'd');
30 | var keys = h.keys;
31 | for (var i = 0; i < 4; i++) {
32 | assert.isTrue(keys.indexOf(i) !== -1);
33 | }
34 | for (i = 0; i < 4; i++) {
35 | assert.isTrue(h.containsKey(i));
36 | }
37 | assert.isFalse(h.containsKey(4));
38 | });
39 |
40 | it.should("know its values", function () {
41 | var h = new MinHeap();
42 | h.insert(0, 'a');
43 | h.insert(1, 'b');
44 | h.insert(2, 'c');
45 | h.insert(3, 'd');
46 | var vals = h.values;
47 | assert.isTrue(vals.indexOf("a") !== -1);
48 | assert.isTrue(vals.indexOf("b") !== -1);
49 | assert.isTrue(vals.indexOf("c") !== -1);
50 | assert.isTrue(vals.indexOf("d") !== -1);
51 | assert.isTrue(h.containsValue("a"));
52 | assert.isTrue(h.containsValue("b"));
53 | assert.isTrue(h.containsValue("c"));
54 | assert.isTrue(h.containsValue("d"));
55 | assert.isFalse(h.containsValue("e"));
56 | });
57 |
58 | it.should("remove items ", function () {
59 | var h = new MinHeap();
60 | h.insert(0, 'a');
61 | h.insert(1, 'b');
62 | h.insert(2, 'c');
63 | h.insert(3, 'd');
64 | assert.isFalse(h.isEmpty);
65 | h.remove();
66 | assert.isFalse(h.isEmpty);
67 | h.remove();
68 | assert.isFalse(h.isEmpty);
69 | h.remove();
70 | assert.isFalse(h.isEmpty);
71 | h.remove();
72 | assert.isTrue(h.isEmpty);
73 | });
74 |
75 | it.should("clear all values", function () {
76 | var h = new MinHeap();
77 | h.insert(0, 'a');
78 | h.insert(1, 'b');
79 | h.insert(2, 'c');
80 | h.insert(3, 'd');
81 | h.clear();
82 | assert.isTrue(h.isEmpty);
83 | assert.equal(h.count, 0, 'count, should be 4');
84 | });
85 |
86 | it.should("peek in order ", function () {
87 | var h = new MinHeap();
88 | h.insert(0, 'a');
89 | h.insert(1, 'b');
90 | h.insert(2, 'c');
91 | h.insert(3, 'd');
92 | assert.equal(h.peekKey(), 0);
93 | assert.equal(h.peek(), "a");
94 | h.clear();
95 | assert.isUndefined(h.peek());
96 | assert.isUndefined(h.peekKey());
97 | h = new MinHeap();
98 | h.insert(1, 'b');
99 | h.insert(3, 'd');
100 | h.insert(0, 'a');
101 | h.insert(2, 'c');
102 | assert.equal(h.peekKey(), 0);
103 | assert.equal(h.peek(), "a");
104 |
105 | });
106 |
107 | it.should("remove elements in order", function () {
108 | var h = new MinHeap();
109 | h.insert(0, 'a');
110 | h.insert(1, 'b');
111 | h.insert(2, 'c');
112 | h.insert(3, 'd');
113 | assert.equal(h.remove(), "a");
114 | assert.equal(h.remove(), "b");
115 | assert.equal(h.remove(), "c");
116 | assert.equal(h.remove(), "d");
117 | h = new MinHeap();
118 | h.insert(1, 'b');
119 | h.insert(3, 'd');
120 | h.insert(0, 'a');
121 | h.insert(2, 'c');
122 | assert.equal(h.remove(), "a");
123 | assert.equal(h.remove(), "b");
124 | assert.equal(h.remove(), "c");
125 | assert.equal(h.remove(), "d");
126 | });
127 |
128 |
129 | it.should("peek as items are inserted ", function () {
130 | var h = new MinHeap();
131 | h.insert(3, 'd');
132 | assert.equal(h.peek(), 'd');
133 | h.insert(2, 'c');
134 | assert.equal(h.peek(), 'c');
135 | h.insert(1, 'b');
136 | assert.equal(h.peek(), 'b');
137 | h.insert(0, 'a');
138 | assert.equal(h.peek(), 'a');
139 | h.clear();
140 | h.insert(1, 'b');
141 | assert.equal(h.peek(), 'b');
142 | h.insert(3, 'd');
143 | assert.equal(h.peek(), 'b');
144 | h.insert(0, 'a');
145 | assert.equal(h.peek(), 'a');
146 | h.insert(2, 'c');
147 | assert.equal(h.peek(), 'a');
148 | });
149 |
150 |
151 | }).as(module);
152 |
153 |
--------------------------------------------------------------------------------
/test/collections/Pool.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Pool = comb.collections.Pool;
6 |
7 | it.describe("comb.collections.Pool", function (it) {
8 |
9 | var p = new Pool();
10 |
11 | it.should("know its minObjects count ", function () {
12 | assert.equal(p.minObjects, 0);
13 | });
14 |
15 | it.should("know its free count", function () {
16 | assert.equal(p.freeCount, 0);
17 | });
18 |
19 | it.should("know its in use count", function () {
20 | assert.equal(p.inUseCount, 0);
21 | });
22 |
23 | it.should("know its total count", function () {
24 | assert.equal(p.count, 0);
25 | });
26 |
27 | it.should("only return 1 object", function () {
28 | var o = p.getObject();
29 | assert.isObject(o);
30 | assert.isUndefined(p.getObject());
31 | p.returnObject(o);
32 | });
33 |
34 | it.should("update the maxObjects ", function () {
35 | p.maxObjects = 3;
36 | var o = p.getObject(), o1 = p.getObject(), o2 = p.getObject();
37 | assert.isObject(o);
38 | assert.isUndefined(p.getObject());
39 | p.maxObjects = 1;
40 | p.returnObject(o2);
41 | p.returnObject(o1);
42 | p.returnObject(o);
43 | assert.equal(p.getObject(), o);
44 | p.returnObject(o);
45 | assert.throws(function () {
46 | p.maxObjects = -1;
47 | });
48 | p.maxObjects = 5;
49 | });
50 |
51 | it.should("update the minObjects ", function () {
52 | p.minObjects = 5;
53 | assert.equal(p.inUseCount, 0);
54 | assert.equal(p.count, 5);
55 | assert.equal(p.freeCount, 5);
56 | assert.equal(p.minObjects, 5);
57 | });
58 |
59 | it.should("throw an error when creating a with maxObjects less than minObject", function () {
60 | assert.throws(function () {
61 | new Pool({maxObject:1, minObjects:3});
62 | });
63 | });
64 |
65 | it.should("return objects properly", function () {
66 | var p = new Pool({maxObjects:3});
67 |
68 | var o1 = p.getObject();
69 | assert.isObject(o1);
70 | assert.equal(p.freeCount, 0);
71 | assert.equal(p.inUseCount, 1);
72 | assert.equal(p.count, 1);
73 | var o2 = p.getObject();
74 | assert.isObject(o2);
75 | assert.equal(p.freeCount, 0);
76 | assert.equal(p.inUseCount, 2);
77 | assert.equal(p.count, 2);
78 | var o3 = p.getObject();
79 | assert.isObject(o3);
80 | assert.equal(p.freeCount, 0);
81 | assert.equal(p.inUseCount, 3);
82 | assert.equal(p.count, 3);
83 | assert.isUndefined(p.getObject());
84 | assert.equal(p.freeCount, 0);
85 | assert.equal(p.inUseCount, 3);
86 | assert.equal(p.count, 3);
87 | p.returnObject(o1);
88 | assert.equal(p.freeCount, 1);
89 | assert.equal(p.inUseCount, 2);
90 | assert.equal(p.count, 3);
91 | p.returnObject(o2);
92 | assert.equal(p.freeCount, 2);
93 | assert.equal(p.inUseCount, 1);
94 | assert.equal(p.count, 3);
95 | p.returnObject(o3);
96 | assert.equal(p.freeCount, 3);
97 | assert.equal(p.inUseCount, 0);
98 | assert.equal(p.count, 3);
99 |
100 | });
101 |
102 | it.should("allow adjusting maxObjects", function () {
103 | var p = new Pool();
104 |
105 | assert.equal(p.freeCount, 0);
106 | assert.equal(p.inUseCount, 0);
107 | assert.equal(p.count, 0);
108 | assert.isObject(p.getObject());
109 | assert.isUndefined(p.getObject());
110 | p.maxObjects = 3;
111 | assert.equal(p.freeCount, 0);
112 | assert.equal(p.inUseCount, 1);
113 | assert.equal(p.count, 1);
114 | assert.isObject(p.getObject());
115 | assert.equal(p.freeCount, 0);
116 | assert.equal(p.inUseCount, 2);
117 | assert.equal(p.count, 2);
118 | assert.isObject(p.getObject());
119 | assert.equal(p.freeCount, 0);
120 | assert.equal(p.inUseCount, 3);
121 | assert.equal(p.count, 3);
122 |
123 | });
124 |
125 | it.describe("creating a new pool maxObjects", function (it) {
126 | var p = new Pool({maxObjects:3});
127 |
128 | it.should("know its maxObjects count ", function () {
129 | assert.equal(p.maxObjects, 3);
130 | });
131 |
132 | it.should("only return 3 object", function () {
133 | assert.isObject(p.getObject());
134 | assert.isObject(p.getObject());
135 | assert.isObject(p.getObject());
136 | assert.isUndefined(p.getObject());
137 | });
138 |
139 | it.should("know its free count", function () {
140 | assert.equal(p.freeCount, 0);
141 | });
142 |
143 | it.should("know its in use count", function () {
144 | assert.equal(p.inUseCount, 3);
145 | });
146 |
147 | it.should("know its total count", function () {
148 | assert.equal(p.count, 3);
149 | });
150 | });
151 | }).as(module);
152 |
--------------------------------------------------------------------------------
/test/collections/PriorityQueue.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | PriorityQueue = comb.collections.PriorityQueue;
6 |
7 | it.describe("comb.collections.PriorityQueue", function (it) {
8 |
9 | it.should("know its count", function () {
10 | var q = new PriorityQueue();
11 | q.enqueue(0, 'a');
12 | q.enqueue(1, 'b');
13 | q.enqueue(2, 'c');
14 | q.enqueue(3, 'd');
15 | assert.equal(q.count, 4);
16 | q.dequeue();
17 | assert.equal(q.count, 3);
18 | q.dequeue();
19 | q.dequeue();
20 | q.dequeue();
21 | assert.equal(q.count, 0);
22 | });
23 |
24 | it.should("know its keys", function () {
25 | var q = new PriorityQueue();
26 | q.enqueue(0, 'a');
27 | q.enqueue(1, 'b');
28 | q.enqueue(2, 'c');
29 | q.enqueue(3, 'd');
30 |
31 | var keys = q.keys;
32 | for (var i = 0; i < 4; i++) {
33 | assert.isTrue(keys.indexOf(i) !== -1);
34 | }
35 | for (i = 0; i < 4; i++) {
36 | assert.isTrue(q.containsKey(i));
37 | }
38 | assert.isFalse(q.containsKey(4));
39 |
40 | });
41 |
42 | it.should("know its values", function () {
43 | var q = new PriorityQueue();
44 | q.enqueue(0, 'a');
45 | q.enqueue(1, 'b');
46 | q.enqueue(2, 'c');
47 | q.enqueue(3, 'd');
48 | var vals = q.values;
49 | assert.isTrue(vals.indexOf("a") !== -1);
50 | assert.isTrue(vals.indexOf("b") !== -1);
51 | assert.isTrue(vals.indexOf("c") !== -1);
52 | assert.isTrue(vals.indexOf("d") !== -1);
53 | assert.isTrue(q.containsValue("a"));
54 | assert.isTrue(q.containsValue("b"));
55 | assert.isTrue(q.containsValue("c"));
56 | assert.isTrue(q.containsValue("d"));
57 | assert.isFalse(q.containsValue("e"));
58 | });
59 |
60 | it.should("dequeue items ", function () {
61 | var q = new PriorityQueue();
62 | q.enqueue(0, 'a');
63 | q.enqueue(1, 'b');
64 | q.enqueue(2, 'c');
65 | q.enqueue(3, 'd');
66 | assert.isFalse(q.isEmpty);
67 | q.dequeue();
68 | assert.isFalse(q.isEmpty);
69 | q.dequeue();
70 | assert.isFalse(q.isEmpty);
71 | q.dequeue();
72 | assert.isFalse(q.isEmpty);
73 | q.dequeue();
74 | assert.isTrue(q.isEmpty);
75 | });
76 |
77 | it.should("clear its items", function () {
78 |
79 | var q = new PriorityQueue();
80 | q.enqueue(0, 'a');
81 | q.enqueue(1, 'b');
82 | q.enqueue(2, 'c');
83 | q.enqueue(3, 'd');
84 | q.clear();
85 | assert.isTrue(q.isEmpty);
86 | assert.equal(q.count, 0, 'count, should be 4');
87 | });
88 |
89 | it.should("peek items in order ", function () {
90 | var q = new PriorityQueue();
91 | q.enqueue(0, 'a');
92 | q.enqueue(1, 'b');
93 | q.enqueue(2, 'c');
94 | q.enqueue(3, 'd');
95 | assert.equal(q.peek(), "a");
96 | q.clear();
97 | assert.isUndefined(q.peek());
98 | q = new PriorityQueue();
99 | q.enqueue(1, 'b');
100 | q.enqueue(3, 'd');
101 | q.enqueue(0, 'a');
102 | q.enqueue(2, 'c');
103 | assert.equal(q.peek(), "a");
104 | });
105 |
106 | it.should("dequeue in order", function () {
107 | var q = new PriorityQueue();
108 | q.enqueue(0, 'a');
109 | q.enqueue(1, 'b');
110 | q.enqueue(2, 'c');
111 | q.enqueue(3, 'd');
112 | assert.equal(q.dequeue(), "a");
113 | assert.equal(q.dequeue(), "b");
114 | assert.equal(q.dequeue(), "c");
115 | assert.equal(q.dequeue(), "d");
116 | q = new PriorityQueue();
117 | q.enqueue(1, 'b');
118 | q.enqueue(3, 'd');
119 | q.enqueue(0, 'a');
120 | q.enqueue(2, 'c');
121 | assert.equal(q.dequeue(), "a");
122 | assert.equal(q.dequeue(), "b");
123 | assert.equal(q.dequeue(), "c");
124 | assert.equal(q.dequeue(), "d");
125 | });
126 |
127 | it.should("peek as enqueued properly", function () {
128 | var q = new PriorityQueue();
129 | q.enqueue(3, 'd');
130 | assert.equal(q.peek(), 'd');
131 | q.enqueue(2, 'c');
132 | assert.equal(q.peek(), 'c');
133 | q.enqueue(1, 'b');
134 | assert.equal(q.peek(), 'b');
135 | q.enqueue(0, 'a');
136 | assert.equal(q.peek(), 'a');
137 | q.clear();
138 | q.enqueue(1, 'b');
139 | assert.equal(q.peek(), 'b');
140 | q.enqueue(3, 'd');
141 | assert.equal(q.peek(), 'b');
142 | q.enqueue(0, 'a');
143 | assert.equal(q.peek(), 'a');
144 | q.enqueue(2, 'c');
145 | assert.equal(q.peek(), 'a');
146 | });
147 |
148 | }).as(module);
149 |
150 |
151 |
--------------------------------------------------------------------------------
/test/collections/Queue.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Queue = comb.collections.Queue;
6 |
7 |
8 | it.describe("comb.collections.Queue", function (it) {
9 | var queue = new Queue();
10 |
11 | it.should("enqueue", function () {
12 | queue.enqueue("test");
13 | assert.isTrue(queue.contains("test"));
14 | assert.equal("test", queue.toString());
15 | });
16 | it.should("dequeue", function () {
17 | assert.equal(queue.dequeue(), "test");
18 | assert.isFalse(queue.contains("test"));
19 | });
20 | it.should("peek", function () {
21 | queue.enqueue("test");
22 | assert.equal(queue.peek(), "test");
23 | assert.isTrue(queue.contains("test"));
24 | });
25 | it.should("know if it is empty", function () {
26 | assert.isFalse(queue.isEmpty);
27 | queue.dequeue();
28 | assert.isTrue(queue.isEmpty);
29 | });
30 | it.should("know its element count", function () {
31 | queue.enqueue("test");
32 | queue.enqueue("test1");
33 | queue.enqueue("test2");
34 | queue.enqueue("test3");
35 | queue.enqueue("test4");
36 | queue.enqueue("test5");
37 | queue.enqueue("test6");
38 | assert.equal(queue.count, 7);
39 | assert.equal(",,test,test1,test2,test3,test4,test5,test6", queue.toString());
40 | });
41 | it.should("return all values", function () {
42 | var vals = ["test", "test1", "test2", "test3", "test4", "test5", "test6"];
43 | assert.isTrue(queue.values.every(function (v, i) {
44 | return v === vals[i];
45 | }));
46 | });
47 |
48 | it.should("remove values", function () {
49 | queue.remove("test6");
50 | queue.remove("test5");
51 | queue.remove("test4");
52 | queue.remove("test3");
53 | queue.remove("test2");
54 | queue.remove("test1");
55 | queue.remove("test");
56 | assert.isTrue(queue.isEmpty);
57 | });
58 |
59 | it.should("clear all elements", function () {
60 | queue.enqueue("test");
61 | queue.enqueue("test1");
62 | queue.enqueue("test2");
63 | queue.enqueue("test3");
64 | queue.enqueue("test4");
65 | queue.enqueue("test5");
66 | queue.enqueue("test6");
67 | assert.isFalse(queue.isEmpty);
68 | assert.equal(",,,test,test1,test2,test3,test4,test5,test6", queue.toString());
69 | queue.clear();
70 | assert.isTrue(queue.isEmpty);
71 | assert.equal(queue.count, 0);
72 | });
73 | it.should("return undefined if empty and dequeue is called", function () {
74 | assert.isUndefined(queue.dequeue());
75 | });
76 |
77 |
78 | }).as(module);
79 |
--------------------------------------------------------------------------------
/test/collections/RedBlackTree.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | helper = require("./treeTest.helper.js"),
6 | Mammal = helper.Mammal,
7 | RedBlackTree = comb.collections.RedBlackTree;
8 |
9 |
10 | it.describe("comb.collections.RedBlackTree", function (it) {
11 |
12 | var words = ["c", "ca", "b", "ba", "bb", "a", "aa", "ab", "z", "d", "f", "h", "i", "ee", "ff", "hi", "j", "ajk"];
13 | var wordsInOrder = [ 'a', 'aa', 'ab', 'ajk', 'b', 'ba', 'bb', 'c', 'ca', 'd', 'ee', 'f', 'ff', 'h', 'hi', 'i', 'j', 'z' ];
14 | var wordsPreOrder = ['d', 'ba', 'aa', 'a', 'ajk', 'ab', 'b', 'c', 'bb', 'ca', 'h', 'f', 'ee', 'ff', 'i', 'hi', 'z', 'j'];
15 | var wordsPostOrder = [ 'a', 'ab', 'b', 'ajk', 'aa', 'bb', 'ca', 'c', 'ba', 'ee', 'ff', 'f', 'hi', 'j', 'z', 'i', 'h', 'd'];
16 |
17 |
18 |
19 | var mammals = [
20 | new Mammal({type:"bird"}),
21 | new Mammal({type:"dog"}),
22 | new Mammal({type:"rat"}),
23 | new Mammal({type:"zebra"}),
24 | new Mammal({type:"mouse"}),
25 | new Mammal({type:"horse"}),
26 | new Mammal({type:"squirrel"}),
27 | new Mammal({type:"groundhog"})
28 | ],
29 |
30 | mammalsInOrder = [
31 | new Mammal({type:"bird"}),
32 | new Mammal({type:"dog"}),
33 | new Mammal({type:"groundhog"}),
34 | new Mammal({type:"horse"}),
35 | new Mammal({type:"mouse"}),
36 | new Mammal({type:"rat"}),
37 | new Mammal({type:"squirrel"}),
38 | new Mammal({type:"zebra"})
39 | ],
40 |
41 | mammalsPreOrder = [
42 | new Mammal({type:"dog"}),
43 | new Mammal({type:"bird"}),
44 | new Mammal({type:"rat"}),
45 | new Mammal({type:"horse"}),
46 | new Mammal({type:"groundhog"}),
47 | new Mammal({type:"mouse"}),
48 | new Mammal({type:"zebra"}),
49 | new Mammal({type:"squirrel"})
50 | ],
51 |
52 | mammalsPostOrder = [
53 | new Mammal({type:"bird"}),
54 | new Mammal({type:"groundhog"}),
55 | new Mammal({type:"mouse"}),
56 | new Mammal({type:"horse"}),
57 | new Mammal({type:"squirrel"}),
58 | new Mammal({type:"zebra"}),
59 | new Mammal({type:"rat"}),
60 | new Mammal({type:"dog"})
61 | ];
62 |
63 | var orderedMammals = [
64 | [RedBlackTree.IN_ORDER, mammalsInOrder],
65 | [RedBlackTree.PRE_ORDER, mammalsPreOrder],
66 | [RedBlackTree.POST_ORDER, mammalsPostOrder]
67 | ];
68 |
69 | var expectedOutput = "\t\t\t\t~\n\t\t\tBLACK:z\n\n\t\t\t\t\t~\n\t\t\t\tRED:j\n\n\t\t\t\t\t~\n\t\tBLACK:i" +
70 | "\n\n\t\t\t\t~\n\t\t\tBLACK:hi\n\n\t\t\t\t~\n\tBLACK:h\n\n\t\t\t\t~\n\t\t\tBLACK:ff\n\n\t\t\t\t~" +
71 | "\n\t\tBLACK:f\n\n\t\t\t\t~\n\t\t\tBLACK:ee\n\n\t\t\t\t~\nBLACK:d\n\n\t\t\t\t~\n\t\t\tBLACK:ca" +
72 | "\n\n\t\t\t\t~\n\t\tBLACK:c\n\n\t\t\t\t~\n\t\t\tBLACK:bb\n\n\t\t\t\t~\n\tBLACK:ba" +
73 | "\n\n\t\t\t\t\t~\n\t\t\t\tRED:b\n\n\t\t\t\t\t~\n\t\t\tBLACK:ajk\n\n\t\t\t\t\t~\n\t\t\t\t" +
74 | "RED:ab\n\n\t\t\t\t\t~\n\t\tBLACK:aa\n\n\t\t\t\t~\n\t\t\tBLACK:a\n\n\t\t\t\t~";
75 | var orderedWords = [
76 | [RedBlackTree.IN_ORDER, wordsInOrder],
77 | [RedBlackTree.PRE_ORDER, wordsPreOrder],
78 | [RedBlackTree.POST_ORDER, wordsPostOrder]
79 | ];
80 |
81 | helper.setup(
82 | it,
83 | RedBlackTree,
84 | words,
85 | orderedWords,
86 | mammals,
87 | orderedMammals,
88 | expectedOutput);
89 |
90 | }).as(module);
--------------------------------------------------------------------------------
/test/collections/Stack.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Stack = comb.collections.Stack;
6 |
7 | it.describe("comb.collections.Stack", function (it) {
8 | var stack = new Stack();
9 |
10 | it.should("push", function () {
11 | stack.push("test");
12 | assert.isTrue(stack.contains("test"));
13 | assert.equal("test", stack.toString());
14 | });
15 |
16 | it.should("pop", function () {
17 | assert.equal(stack.pop(), "test");
18 | assert.isFalse(stack.contains("test"));
19 | });
20 |
21 | it.should("peek", function () {
22 | stack.push("test");
23 | assert.equal(stack.peek(), "test");
24 | assert.isTrue(stack.contains("test"));
25 | });
26 |
27 | it.should("know if it is empty", function () {
28 | assert.isFalse(stack.isEmpty);
29 | stack.pop();
30 | assert.isTrue(stack.isEmpty);
31 | });
32 |
33 | it.should("know its element count", function () {
34 | stack.push("test");
35 | stack.push("test1");
36 | stack.push("test2");
37 | stack.push("test3");
38 | stack.push("test4");
39 | stack.push("test5");
40 | stack.push("test6");
41 | assert.equal(stack.count, 7);
42 | assert.equal("test,test1,test2,test3,test4,test5,test6", stack.toString());
43 | });
44 |
45 | it.should("pop values", function () {
46 | assert.equal(stack.pop(), "test6");
47 | assert.equal(stack.pop(), "test5");
48 | assert.equal(stack.pop(), "test4");
49 | assert.equal(stack.pop(), "test3");
50 | assert.equal(stack.pop(), "test2");
51 | assert.equal(stack.pop(), "test1");
52 | assert.equal(stack.pop(), "test");
53 | assert.equal(stack.count, 0);
54 | });
55 |
56 | it.should("return all values", function () {
57 | stack.push("test");
58 | stack.push("test1");
59 | stack.push("test2");
60 | stack.push("test3");
61 | stack.push("test4");
62 | stack.push("test5");
63 | stack.push("test6");
64 | var vals = ["test", "test1", "test2", "test3", "test4", "test5", "test6"].reverse();
65 | assert.isTrue(stack.values.every(function (v, i) {
66 | return v === vals[i];
67 | }));
68 | assert.equal("test,test1,test2,test3,test4,test5,test6", stack.toString());
69 | });
70 |
71 | it.should("remove values", function () {
72 | stack.remove("test");
73 | stack.remove("test1");
74 | stack.remove("test2");
75 | stack.remove("test3");
76 | stack.remove("test4");
77 | stack.remove("test5");
78 | stack.remove("test6");
79 | assert.isTrue(stack.isEmpty);
80 | });
81 |
82 | it.should("clear all elements", function () {
83 | stack.push("test");
84 | stack.push("test1");
85 | stack.push("test2");
86 | stack.push("test3");
87 | stack.push("test4");
88 | stack.push("test5");
89 | stack.push("test6");
90 | assert.isFalse(stack.isEmpty);
91 | stack.clear();
92 | assert.isTrue(stack.isEmpty);
93 | assert.equal(stack.count, 0);
94 | });
95 |
96 | it.should("return undefined if empty and dequeue is called", function () {
97 | assert.isUndefined(stack.pop());
98 | });
99 |
100 | }).as(module);
101 |
--------------------------------------------------------------------------------
/test/collections/Tree.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | Tree = comb.collections.Tree;
6 |
7 |
8 | it.describe("A Tree interface", function (it) {
9 | var methods = ["insert", "remove"];
10 |
11 | var tree = new Tree();
12 | methods.forEach(function (m) {
13 | it.describe("#" + m, function (it) {
14 | it.should("be abstract", function () {
15 | assert.throws(function () {
16 | tree[m]();
17 | });
18 | });
19 | });
20 | });
21 |
22 | }).as(module);
23 |
24 |
--------------------------------------------------------------------------------
/test/extensions/is.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var comb = require("../../index"),
3 | assert = require("assert"),
4 | it = require("it");
5 |
6 | it.describe("is extension",function (it) {
7 |
8 | it.should("expose equality methods", function () {
9 | assert.isTrue(comb(1).eq(1));
10 | assert.isFalse(comb(1).eq(2));
11 | assert.isTrue(comb("hello").eq("hello"));
12 | assert.isFalse(comb("hello").eq("world"));
13 | assert.isFalse(comb(new Date(2001, 1, 1, 1, 1, 1, 111)).eq(new Date(2001, 1, 1, 1, 1, 1, 111)));
14 | assert.isFalse(comb({}).eq({}));
15 | });
16 |
17 | it.should("expose neq methods", function () {
18 | assert.isFalse(comb(1).neq(1));
19 | assert.isTrue(comb(1).neq(2));
20 | assert.isFalse(comb("hello").neq("hello"));
21 | assert.isTrue(comb("hello").neq("world"));
22 | assert.isTrue(comb(new Date(2001, 1, 1, 1, 1, 1, 111)).neq(new Date(2001, 1, 1, 1, 1, 1, 111)));
23 | assert.isTrue(comb({}).neq({}));
24 | });
25 |
26 | it.should("expose value of properly", function () {
27 | var date = new Date(2001, 1, 1, 1, 1, 1, 111),
28 | date2 = new Date(2001, 1, 1, 1, 1, 1, 111);
29 | assert.deepEqual(comb(date).valueOf(), date.valueOf());
30 | assert.strictEqual(comb("hello").valueOf(), "hello");
31 | assert.strictEqual(comb(true).valueOf(), true);
32 | assert.deepEqual(comb({}).valueOf(), {});
33 | });
34 |
35 | it.should("print properly", function () {
36 | var orig = console.log, val;
37 | console.log = function (arg) {
38 | val = arg;
39 | };
40 | comb("hello").print();
41 | assert.strictEqual(val, "hello");
42 |
43 | comb(1).print();
44 | assert.strictEqual(val, 1);
45 |
46 | comb(true).print();
47 | assert.strictEqual(val, true);
48 | console.log = orig;
49 | });
50 |
51 | }).as(module);
--------------------------------------------------------------------------------
/test/logging/appenders/appender.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../../index"),
5 | logging = comb.logging,
6 | Appender = logging.appenders.Appender;
7 |
8 | it.describe("comb.logging.appenders.Appender", function (it) {
9 |
10 | var MyAppender = comb.define(Appender, {
11 | instance: {
12 | append: function (event) {
13 | if (this._canAppend(event)) {
14 | this.onAppend(comb.string.format(this.__pattern, event));
15 | }
16 | },
17 |
18 | onAppend: function () {
19 |
20 | }
21 | }
22 | }).registerType("MyAppender");
23 |
24 |
25 | var logger1 = logging.Logger.getLogger("AppenderTest"),
26 | logger2 = logging.Logger.getLogger("AppenderTest.one"),
27 | logger3 = logging.Logger.getLogger("AppenderTest.one.two");
28 | it.describe("adding appender to loggers", function (it) {
29 | var appender;
30 | it.beforeAll(function () {
31 | appender = new Appender({name: "myAppender1"});
32 | logger1.addAppender(appender);
33 | });
34 |
35 | it.should("be added to all subloggers", function () {
36 | assert.isTrue(logger1.isAppenderAttached(appender.name));
37 | assert.isTrue(logger2.isAppenderAttached(appender.name));
38 | assert.isTrue(logger3.isAppenderAttached(appender.name));
39 | });
40 |
41 | it.should("have it level defaulted to all", function () {
42 | assert.equal(appender.level, logging.Level.ALL);
43 | });
44 |
45 | it.should("allow its level to be set", function () {
46 | appender.level = "info";
47 | assert.equal(appender.level, logging.Level.INFO);
48 | });
49 |
50 | it.should("allow its pattern to be set", function () {
51 | appender.pattern = "{message}";
52 | assert.equal(appender.pattern, "{message}");
53 | });
54 |
55 | it.should("be removed from loggers if removeAllAppenders is called", function () {
56 | logger1.removeAppender(appender.name);
57 | assert.isFalse(logger1.isAppenderAttached(appender.name));
58 | assert.isFalse(logger2.isAppenderAttached(appender.name));
59 | assert.isFalse(logger3.isAppenderAttached(appender.name));
60 | logger2.addAppenders([appender]);
61 | assert.isFalse(logger1.isAppenderAttached(appender.name));
62 | assert.isTrue(logger2.isAppenderAttached(appender.name));
63 | assert.isTrue(logger3.isAppenderAttached(appender.name));
64 | logger2.removeAppenders([appender.name]);
65 | assert.isFalse(logger1.isAppenderAttached(appender.name));
66 | assert.isFalse(logger2.isAppenderAttached(appender.name));
67 | assert.isFalse(logger3.isAppenderAttached(appender.name));
68 | logger3.addAppender(appender);
69 | assert.isFalse(logger1.isAppenderAttached(appender.name));
70 | assert.isFalse(logger2.isAppenderAttached(appender.name));
71 | assert.isTrue(logger3.isAppenderAttached(appender.name));
72 | logger3.removeAllAppenders();
73 | assert.isFalse(logger1.isAppenderAttached(appender.name));
74 | assert.isFalse(logger2.isAppenderAttached(appender.name));
75 | assert.isFalse(logger3.isAppenderAttached(appender.name));
76 | });
77 |
78 | it.should("throw an error if append is called", function () {
79 | assert.throws(function () {
80 | appender.append();
81 | });
82 | });
83 | });
84 |
85 | it.describe("adding an appender and setting the level ", function (it) {
86 | var topic;
87 | it.beforeAll(function () {
88 | topic = new MyAppender({level: 6});
89 | });
90 |
91 | it.should("have its level set to FATAL", function () {
92 | assert.equal(topic.level, logging.Level.FATAL);
93 | });
94 |
95 | it.should("only log fatal messages ", function () {
96 | logger1.addAppender(topic);
97 | topic.level = 6;
98 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
99 | var count = 0;
100 | comb.connect(topic, "onAppend", function () {
101 | count++;
102 | });
103 | levels.forEach(function (l) {
104 | logger1[l](l);
105 | logger2[l](l);
106 | logger3[l](l);
107 | });
108 | assert.equal(count, 3);
109 |
110 | });
111 |
112 | });
113 |
114 | it.describe(".createAppender", function (it) {
115 | it.should("create an appender from a type", function () {
116 | var appender = Appender.createAppender("MyAppender");
117 | assert.instanceOf(appender, MyAppender);
118 | });
119 |
120 | it.should("throw an error if an appender is not registered", function () {
121 | assert.throws(function () {
122 | Appender.createAppender("nonexistentappender");
123 | });
124 | });
125 | });
126 |
127 | }).as(module);
128 |
--------------------------------------------------------------------------------
/test/logging/appenders/consoleAppender.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../../index"),
5 | logging = comb.logging,
6 | ConsoleAppender = logging.appenders.ConsoleAppender;
7 |
8 |
9 | it.describe("comb.logging.appenders.ConsoleAppender", function (it) {
10 |
11 | var logger = comb.logger("ConsoleLoggerTest"), appender;
12 | it.beforeAll(function () {
13 | appender = new ConsoleAppender();
14 | logger.addAppender(appender);
15 | });
16 |
17 | it.should("be added to the logger", function () {
18 | assert.isTrue(logger.isAppenderAttached("consoleAppender"));
19 | assert.deepEqual(logger.appenders, [appender]);
20 | });
21 |
22 |
23 | it.should("have then logged to the appender ", function () {
24 | var orig = console.log;
25 | try {
26 | var count = 0;
27 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
28 | console.log = function (str) {
29 | assert.isTrue(str.match(levels[count]) != null);
30 | count++;
31 | };
32 | levels.forEach(function (l) {
33 | logger[l](l);
34 | });
35 | assert.equal(count, 6);
36 | } catch (e) {
37 | throw e;
38 | } finally {
39 | console.log = orig;
40 | }
41 |
42 | });
43 |
44 | it.should("the logger should log no events to the appender ", function () {
45 |
46 | var orig = console.log;
47 | try {
48 | logger.level = logging.Level.OFF;
49 | var count = 0;
50 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
51 | console.log = function (str) {
52 | assert.isTrue(str.match(levels[count]) != null);
53 | count++;
54 | };
55 | levels.forEach(function (l) {
56 | logger[l](l);
57 | });
58 | assert.equal(count, 0);
59 | } catch (e) {
60 | throw e;
61 | } finally {
62 | console.log = orig;
63 | }
64 | });
65 |
66 | it.should("have an wrapStyle option to turn off style", function () {
67 | var styleLogger = comb.logger("ConsoleLoggerIncludeStyleTest"),
68 | styleAppender = new ConsoleAppender({
69 | wrapStyle: false,
70 | pattern: "{message}"
71 | }),
72 | orig = console.log;
73 | styleLogger.addAppender(styleAppender);
74 | try {
75 | var count = 0;
76 | var levels = ["debug", "info", "warn", "error", "fatal"];
77 | console.log = function (str) {
78 | assert.equal(str, levels[count]);
79 | count++;
80 | };
81 | levels.forEach(function (l) {
82 | styleLogger[l](l);
83 | });
84 | assert.equal(count, 5);
85 |
86 | console.log = function (str) {
87 | assert.isTrue(str.match(/Trace: message/) != null);
88 | count++;
89 | };
90 | styleLogger.trace("message");
91 | } catch (e) {
92 | throw e;
93 | } finally {
94 | console.log = orig;
95 | }
96 | });
97 |
98 | it.should("supports levelNameColored property", function () {
99 | var styleLogger = comb.logger("ConsoleLoggerIncludeStyleTest2"),
100 | styleAppender = new ConsoleAppender({
101 | wrapStyle: false,
102 | pattern: "{levelNameColored} {message}"
103 | }),
104 | orig = console.log;
105 | styleLogger.addAppender(styleAppender);
106 | try {
107 | var count = 0;
108 | console.log = function (str) {
109 | assert.equal(str, "\x1B[31mERROR\x1B[0m message");
110 | count++;
111 | };
112 | styleLogger.error("message");
113 | assert.equal(count, 1);
114 | } catch (e) {
115 | throw e;
116 | } finally {
117 | console.log = orig;
118 | }
119 | });
120 |
121 | }).as(module);
122 |
--------------------------------------------------------------------------------
/test/logging/appenders/fileAppender.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../../index"),
5 | logging = comb.logging,
6 | FileAppender = logging.appenders.FileAppender;
7 |
8 |
9 | it.describe("comb.logging.appenders.FileAppender", function (it) {
10 |
11 | var MockWriteStream = {
12 | writable: true,
13 | on: function () {
14 | },
15 | destroySoon: function () {
16 | },
17 | write: function (str) {
18 | return str;
19 | }
20 | };
21 |
22 | var logger = logging.Logger.getLogger("FilerAppenderTest"),
23 | appender = new FileAppender({writeStream: MockWriteStream});
24 | logger.addAppender(appender);
25 |
26 | it.should("be added to the logger", function () {
27 | assert.isTrue(logger.isAppenderAttached("fileAppender"));
28 | assert.deepEqual(logger.appenders, [appender]);
29 | });
30 |
31 | it.should("have events logged to it by the logger according to level", function () {
32 |
33 | var count = 0;
34 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
35 | var conn = comb.connect(MockWriteStream, "write", function (str) {
36 | assert.isTrue(str.match(levels[count]) != null);
37 | count++;
38 | });
39 | levels.forEach(function (l) {
40 | logger[l](l);
41 | });
42 | assert.equal(count, 6);
43 | comb.disconnect(conn);
44 |
45 |
46 | logger.level = logging.Level.OFF;
47 | count = 0;
48 | conn = comb.connect(MockWriteStream, "write", function (str) {
49 | assert.isTrue(str.match(levels[count]) != null);
50 | count++;
51 | });
52 | levels.forEach(function (l) {
53 | logger[l](l);
54 | });
55 | assert.equal(count, 0);
56 | comb.disconnect(conn);
57 |
58 |
59 | });
60 |
61 |
62 | }).as(module);
63 |
--------------------------------------------------------------------------------
/test/logging/appenders/jsonAppender.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../../index"),
5 | logging = comb.logging,
6 | JSONAppender = logging.appenders.JSONAppender;
7 |
8 |
9 | it.describe("comb.logging.appenders.JSONAppender", function (it) {
10 |
11 | var MockWriteStream = {
12 | writable: true,
13 | on: function () {
14 | },
15 | destroySoon: function () {
16 | },
17 | write: function (str) {
18 | return str;
19 | }
20 | };
21 |
22 | var logger = logging.Logger.getLogger("JSONAppenderTest"),
23 | appender = new JSONAppender({writeStream: MockWriteStream});
24 | logger.addAppender(appender);
25 |
26 | it.should("be added to the logger", function () {
27 | assert.isTrue(logger.isAppenderAttached("JSONAppender"));
28 | assert.deepEqual(logger.appenders, [appender]);
29 | });
30 |
31 | it.should("have events logged to it by the logger according to level", function () {
32 |
33 | var count = 0;
34 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
35 | var conn = comb.connect(MockWriteStream, "write", function (str) {
36 | if (!str.match(/^\[|\]$/)) {
37 | str = str.replace(/^,/, "");
38 | var obj = JSON.parse(str);
39 | assert.isTrue(obj.message.match(levels[count]) != null);
40 | count++;
41 | }
42 | });
43 | levels.forEach(function (l) {
44 | logger[l](l);
45 | });
46 | assert.equal(count, 6);
47 | comb.disconnect(conn);
48 | logger.level = logging.Level.OFF;
49 | count = 0;
50 | conn = comb.connect(MockWriteStream, "write", function (str) {
51 | count++;
52 | });
53 | levels.forEach(function (l) {
54 | logger[l](l);
55 | });
56 | assert.equal(count, 0);
57 | comb.disconnect(conn);
58 | });
59 |
60 | }).as(module);
61 |
62 |
63 |
--------------------------------------------------------------------------------
/test/logging/appenders/rollingFileAppender.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../../index"),
5 | logging = comb.logging,
6 | RollingFileAppender = logging.appenders.RollingFileAppender,
7 | fs = require("fs");
8 |
9 |
10 | it.describe("comb.logging.appenders.RollingFileAppender", function (it) {
11 | var origWatch = fs.watchFile;
12 | var origStat = fs.stat;
13 | var origCreateWriteStream = fs.createWriteStream;
14 | var origReadDir = fs.readdir;
15 | var origUnlink = fs.unlink;
16 | var origRename = fs.rename;
17 |
18 | var size = 0, callwatch;
19 | var setUpFS = function () {
20 | fs.watchFile = function (name, cb) {
21 | //do nothing
22 | };
23 |
24 | fs.stat = function (name, cb) {
25 | setTimeout(comb.partial(cb, null, {size: size++ % 2 ? 1024 : 0}), 10);
26 | };
27 |
28 | fs.createWriteStream = function () {
29 | return MockWriteStream;
30 | };
31 |
32 | fs.readdir = function (dir, cb) {
33 | var ret = ["log.log.3", "noMatch.log.3", "log.log", "log.log.1", "log.log.2"];
34 | setTimeout(comb.partial(cb, null, ret), 10);
35 | };
36 |
37 | fs.unlink = function (str, cb) {
38 | setTimeout(cb, 10);
39 | };
40 |
41 | fs.rename = function (str, str2, cb) {
42 | setTimeout(cb, 10);
43 | };
44 | };
45 |
46 | var resetFs = function () {
47 | fs.watchFile = origWatch;
48 | fs.stat = origStat;
49 | fs.createWriteStream = origCreateWriteStream;
50 | fs.readdir = origReadDir;
51 | fs.unlink = origUnlink;
52 | fs.rename = origRename;
53 | };
54 |
55 | var MockWriteStream = {
56 | writable: true,
57 | on: function (str, cb) {
58 | cb();
59 | },
60 | destroySoon: function () {
61 | },
62 | write: function (str) {
63 | return str;
64 | }
65 | };
66 | var appender, logger;
67 | it.beforeAll(function () {
68 | logger = logging.Logger.getLogger("RollingFileAppenderTest");
69 | setUpFS();
70 | appender = new RollingFileAppender({writeStream: MockWriteStream, maxSize: "1KB", maxBackupIndex: 3});
71 | logger.addAppender(appender);
72 | });
73 |
74 |
75 | it.should("be added to the logger", function () {
76 | assert.isTrue(logger.isAppenderAttached("rollingFileAppender"));
77 | assert.deepEqual(logger.appenders, [appender]);
78 | });
79 |
80 | it.should("have events logged to it", function () {
81 | var count = 0;
82 | var levels = ["debug", "trace", "info", "warn", "error", "fatal"];
83 | var conn = comb.connect(MockWriteStream, "write", function (str) {
84 | assert.isTrue(str.match(levels[count]) != null);
85 | count++;
86 | });
87 | levels.forEach(function (l) {
88 | logger[l](l);
89 | });
90 | assert.equal(count, 6);
91 | comb.disconnect(conn);
92 |
93 | logger.level = logging.Level.OFF;
94 | count = 0;
95 | conn = comb.connect(MockWriteStream, "write", function (str) {
96 | count++;
97 | });
98 | levels.forEach(function (l) {
99 | logger[l](l);
100 | });
101 | assert.equal(count, 0);
102 | comb.disconnect(conn);
103 |
104 | });
105 |
106 |
107 | it.should("rollover files ", function (next) {
108 |
109 | logger.level = logging.Level.INFO;
110 | var renameLogs = [
111 | {name: "./log.log.2", newName: "./log.log.3"},
112 | {name: "./log.log.1", newName: "./log.log.2"},
113 | {name: "./log.log", newName: "./log.log.1"}
114 | ];
115 | var unlinkCount = 0, renameCount = 0, logCount = 0;
116 | var unlinkConn = comb.connect(fs, "unlink", comb.hitch(this, function (name) {
117 | assert.isTrue(name === "./log.log.3");
118 | unlinkCount++;
119 | }));
120 | var conn = comb.connect(MockWriteStream, "write", function (str) {
121 | logCount++;
122 | });
123 | var renameConn = comb.connect(fs, "rename", comb.hitch(this, function (name, newName) {
124 | var o = renameLogs[renameCount];
125 | assert.isTrue(name === o.name);
126 | assert.isTrue(newName === o.newName);
127 | renameCount++;
128 | }));
129 | var called = false;
130 | //max sure that the callback is called right away
131 | appender.__checkFile({size: 1023})
132 | .chain(function () {
133 | called = true;
134 | })
135 | .chain(function () {
136 |
137 | assert.isTrue(called);
138 | //set the next state
139 | called = false;
140 | appender.__inRollover = true;
141 | return appender.__checkFile({size: 1025}).chain(comb.hitch(this, function () {
142 | called = true;
143 | }));
144 |
145 | })
146 | .chain(function () {
147 | assert.isTrue(called);
148 | appender.__inRollover = false;
149 | called = false;
150 | //now make sure it just creates a new write stream;
151 | appender.maxBackupIndex = 0;
152 | appender.__checkFile({size: 1025}).then(comb.hitch(this, function () {
153 | called = true;
154 | })).chain(function () {
155 |
156 | assert.isTrue(called);
157 | appender.maxBackupIndex = 3;
158 | called = false;
159 | //now make sure it acutally rolls over
160 | appender.__checkFile({size: 1025}).then(comb.hitch(this, function () {
161 | called = true;
162 | assert.equal(unlinkCount, 1);
163 | assert.equal(renameCount, 3);
164 | assert.equal(logCount, 3);
165 | next();
166 | }));
167 |
168 | assert.isFalse(called);
169 | logger.info("hello");
170 | logger.info("hello2");
171 | logger.info("hello3");
172 |
173 | });
174 | });
175 | });
176 |
177 |
178 | it.afterAll(resetFs);
179 |
180 |
181 | }).as(module);
182 |
183 |
--------------------------------------------------------------------------------
/test/plugins/Broadcaster.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | define = comb.define,
6 | hitch = comb.hitch;
7 |
8 |
9 | it.describe("comb.plugins.Broadcaster", function (it) {
10 | //Super of other classes
11 | var Mammal = define(comb.plugins.Broadcaster, {
12 | instance: {
13 |
14 | constructor: function (options) {
15 | options = options || {};
16 | this._super(arguments);
17 | this._type = options.type || "mammal";
18 | },
19 |
20 | speak: function () {
21 | var str = "A mammal of type " + this._type + " sounds like";
22 | this.broadcast("speak", str);
23 | this.onSpeak(str);
24 | return str;
25 | },
26 |
27 | onSpeak: function () {
28 |
29 | }
30 | }
31 | });
32 |
33 | it.should("broadcast a speak event", function (next) {
34 | var m = new Mammal({color: "gold"});
35 | m.listen("speak", function (str) {
36 | assert.equal(str, "A mammal of type mammal sounds like");
37 | next();
38 | });
39 | m.speak();
40 | });
41 |
42 | it.should("should unListen a listener", function (next) {
43 | var m = new Mammal({color: "gold"});
44 | var han = m.listen("speak", function () {
45 | next("Should not have called");
46 | });
47 | m.unListen(han);
48 | m.listen("speak", hitch(this, function (str) {
49 | assert.equal(str, "A mammal of type mammal sounds like");
50 | next();
51 | }));
52 | m.speak();
53 | });
54 |
55 |
56 | }).as(module);
57 |
58 |
59 |
60 |
--------------------------------------------------------------------------------
/test/plugins/Middleware.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../../index"),
5 | define = comb.define,
6 | hitch = comb.hitch;
7 |
8 |
9 | it.describe("comb.plugins.Middleware",function (it) {
10 | //Super of other classes
11 | function valWrapper(val) {
12 | return function () {
13 | return val;
14 | };
15 | }
16 |
17 | var Mammal = define(comb.plugins.Middleware, {
18 | instance:{
19 |
20 | constructor:function (options) {
21 | options = options || {};
22 | this._super(arguments);
23 | this._type = options.type || "mammal";
24 | },
25 |
26 | speak:function () {
27 | return this._hook("pre", "speak")
28 | .chain(comb.hitch(this, "_hook", "post", "speak"))
29 | .chain(valWrapper("speak")).promise();
30 | },
31 |
32 | speakAgain:function () {
33 | return this._hook("pre", "speakAgain")
34 | .chain(comb.hitch(this, "_hook", "post", "speakAgain"))
35 | .chain(valWrapper("speakAgain")).promise();
36 |
37 | },
38 |
39 | eat:function () {
40 | return this._hook("pre", "eat")
41 | .chain(comb.hitch(this, "_hook", "post", "eat"))
42 | .chain(valWrapper("eat")).promise();
43 | }
44 | }
45 | });
46 |
47 | it.should("call pre middleware", function (next) {
48 | Mammal.pre('speak', function (n) {
49 | assert.isTrue(comb.isFunction(n));
50 | n();
51 | next();
52 | });
53 | var m = new Mammal({color:"gold"});
54 | m.speak();
55 | });
56 |
57 | it.should("call pre middleware on an instance of middleware", function (next) {
58 | var m = new Mammal({color:"gold"});
59 | m.pre('speakAgain', function (n) {
60 | assert.isTrue(comb.isFunction(n));
61 | n();
62 | next();
63 | });
64 | m.speakAgain();
65 | });
66 |
67 | it.should("call post middleware", function (next) {
68 | Mammal.post('speak', function (n) {
69 | assert.isTrue(comb.isFunction(n));
70 | n();
71 | next();
72 | });
73 | var m = new Mammal({color:"gold"});
74 | m.speak();
75 | });
76 |
77 | it.should("call post middleware on an instance of middleware", function (next) {
78 | var m = new Mammal({color:"gold"});
79 | m.post('speakAgain', function (n) {
80 | assert.isTrue(comb.isFunction(n));
81 | n();
82 | next();
83 | });
84 | m.speakAgain();
85 | });
86 |
87 | it.should("callback right away if there is no middleware", function (next) {
88 | var m = new Mammal({color:"gold"});
89 | m.eat().then(comb.hitch(this, function (str) {
90 | assert.equal(str, "eat");
91 | next();
92 | }));
93 | });
94 |
95 | it.should("errback if the first argument to next is not null/undefined", function (next) {
96 | Mammal.pre('speak', function (n) {
97 | assert.isTrue(comb.isFunction(n));
98 | n("error");
99 | });
100 | var m = new Mammal({color:"gold"});
101 | m.speak().then(next, function (err) {
102 | assert.equal(err, "error");
103 | next();
104 | });
105 | });
106 |
107 | }).as(module);
108 |
109 |
110 |
111 |
--------------------------------------------------------------------------------
/test/promiseList.test.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var it = require('it'),
3 | assert = require('assert'),
4 | comb = require("../index"),
5 | Promise = comb.Promise,
6 | PromiseList = comb.PromiseList;
7 |
8 | it.describe("comb.PromiseList", function (it) {
9 |
10 |
11 | it.should("should callback after all have fired ", function (next) {
12 |
13 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
14 | setTimeout(comb.hitch(promise, "callback", "hello"), 100);
15 | setTimeout(comb.hitch(promise2, "callback", "world"), 150);
16 | setTimeout(comb.hitch(promise3, "callback", "!"), 200);
17 | new PromiseList([promise, promise2, promise3]).then(function (res) {
18 | var expected = ["hello", "world", "!"];
19 | res.forEach(function (r, i) {
20 | assert.equal(r[1], expected[i]);
21 | });
22 | next();
23 | }, next);
24 | });
25 |
26 | it.should("callback immediately if no promises are provided", function (next) {
27 | new PromiseList().then(function (res) {
28 | assert.deepEqual(res, []);
29 | next();
30 | }, next);
31 | });
32 |
33 | it.should("callback immediately if and empty array is provided", function (next) {
34 | new PromiseList([]).then(function (res) {
35 | assert.deepEqual(res, []);
36 | next();
37 | }, next);
38 | });
39 |
40 | it.should("callback if provided promises that have already fired", function (next) {
41 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
42 | promise.callback("hello");
43 | promise2.callback("world");
44 | promise3.callback("!");
45 | new PromiseList([promise, promise2, promise3]).then(function (res) {
46 | var expected = ["hello", "world", "!"];
47 | res.forEach(function (r, i) {
48 | assert.equal(r[1], expected[i]);
49 | });
50 | next();
51 | }, next);
52 | });
53 |
54 | it.should("errback if provided promises that have already fired and one errored back", function (next) {
55 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
56 | promise.callback("hello");
57 | promise2.callback("world");
58 | promise3.errback("error");
59 | var pl = new PromiseList([promise, promise2, promise3]);
60 | process.nextTick(function () {
61 | pl.then(next, function (res) {
62 | res.forEach(function (res) {
63 | assert.equal(res[1], "error");
64 | });
65 | next();
66 | });
67 | });
68 | });
69 |
70 | it.should("throw an error if callback is called after firing", function (next) {
71 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
72 | promise.callback("hello");
73 | promise2.callback("world");
74 | promise3.callback("!");
75 | var pl = new PromiseList([promise, promise2, promise3]);
76 | pl.addCallback(function () {
77 | assert.throws(function () {
78 | pl.callback();
79 | });
80 | });
81 | return pl;
82 | });
83 |
84 | it.should("throw an error if errback is called after firing", function (next) {
85 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
86 | promise.callback("hello");
87 | promise2.callback("world");
88 | promise3.callback("!");
89 | var pl = new PromiseList([promise, promise2, promise3]);
90 | pl.addCallback(function () {
91 | assert.throws(function () {
92 | pl.errback();
93 | });
94 | });
95 | return pl;
96 | });
97 |
98 | it.should("handle the ordering of results if resolved out of order", function (next) {
99 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
100 | setTimeout(comb.hitch(promise, "callback", "hello"), 200);
101 | setTimeout(comb.hitch(promise2, "callback", "world"), 150);
102 | setTimeout(comb.hitch(promise3, "callback", "!"), 100);
103 | new PromiseList([promise, promise2, promise3]).then(function (res) {
104 | var expected = ["hello", "world", "!"];
105 | res.forEach(function (res, i) {
106 | assert.equal(res[1], expected[i]);
107 | });
108 | next();
109 | }, next);
110 | });
111 |
112 | it.should("normalize results", function (next) {
113 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
114 | setTimeout(comb.hitch(promise, "callback", "hello"), 200);
115 | setTimeout(comb.hitch(promise2, "callback", "world"), 150);
116 | setTimeout(comb.hitch(promise3, "callback", "!"), 100);
117 | new PromiseList([promise, promise2, promise3], true).then(function (res) {
118 | assert.deepEqual(res, ["hello", "world", "!"]);
119 | next();
120 | }, next);
121 | });
122 |
123 | it.should("accept a promise as a callback", function (next) {
124 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
125 | process.nextTick(comb.hitch(promise, "callback", "hello"));
126 | process.nextTick(comb.hitch(promise2, "callback", "world"));
127 | process.nextTick(comb.hitch(promise3, "callback", "!"));
128 | var p2 = new Promise();
129 | p2.then(function (res) {
130 | assert.deepEqual(res, ["hello", "world", "!"]);
131 | next();
132 | });
133 | new PromiseList([promise, promise2, promise3], true).addCallback(p2).addErrback(next);
134 | });
135 |
136 | it.should("accept a promise as a errback", function (next) {
137 | var promise = new Promise(), promise2 = new Promise(), promise3 = new Promise();
138 | process.nextTick(comb.hitch(promise, "callback", "hello"));
139 | process.nextTick(comb.hitch(promise2, "callback", "world"));
140 | process.nextTick(comb.hitch(promise3, "errback", "error"));
141 | var p2 = new Promise();
142 | p2.then(next, function (res) {
143 | assert.equal(res[2], "error");
144 | next();
145 | });
146 | new PromiseList([promise, promise2, promise3], true).addCallback(next).addErrback(p2);
147 | });
148 |
149 | }).as(module);
150 |
--------------------------------------------------------------------------------