vulcan 0.0.1 → 0.0.2

data/server/node_modules/cradle/node_modules/vows/test/fixtures/isolate/failing.js

@@ -0,0 +1,18 @@
+var vows = require('../../../lib/vows'),
+    assert = require('assert');
+
+var obvious;
+vows.describe('failing').addBatch({
+  'Obvious test': obvious = {
+    topic: function () {
+      this.callback(null, false);
+    },
+    'should work': function (result) {
+      assert.ok(result);
+    }
+    // but it won't
+  },
+  'Obvious test #2': obvious,
+  'Obvious test #3': obvious,
+  'Obvious test #4': obvious
+}).export(module);

data/server/node_modules/cradle/node_modules/vows/test/fixtures/isolate/log.js

@@ -0,0 +1,18 @@
+var vows = require('../../../lib/vows'),
+    assert = require('assert');
+
+var obvious;
+vows.describe('stderr').addBatch({
+  'Obvious test': obvious = {
+    topic: function () {
+      this.callback(null, true);
+    },
+    'should work': function (result) {
+      console.log('oh no!');
+      assert.ok(result);
+    }
+  },
+  'Obvious test #2': obvious,
+  'Obvious test #3': obvious,
+  'Obvious test #4': obvious
+}).export(module);

data/server/node_modules/cradle/node_modules/vows/test/fixtures/isolate/passing.js

@@ -0,0 +1,17 @@
+var vows = require('../../../lib/vows'),
+    assert = require('assert');
+
+var obvious;
+vows.describe('passing').addBatch({
+  'Obvious test': obvious = {
+    topic: function () {
+      this.callback(null, true);
+    },
+    'should work': function (result) {
+      assert.ok(result);
+    }
+  },
+  'Obvious test #2': obvious,
+  'Obvious test #3': obvious,
+  'Obvious test #4': obvious
+}).export(module);

data/server/node_modules/cradle/node_modules/vows/test/fixtures/isolate/stderr.js

@@ -0,0 +1,18 @@
+var vows = require('../../../lib/vows'),
+    assert = require('assert');
+
+var obvious;
+vows.describe('stderr').addBatch({
+  'Obvious test': obvious = {
+    topic: function () {
+      this.callback(null, true);
+    },
+    'should work': function (result) {
+      console.error('oh no!');
+      assert.ok(result);
+    }
+  },
+  'Obvious test #2': obvious,
+  'Obvious test #3': obvious,
+  'Obvious test #4': obvious
+}).export(module);

data/server/node_modules/cradle/node_modules/vows/test/isolate-test.js

@@ -0,0 +1,140 @@
+var vows = require('../lib/vows'),
+    assert = require('assert'),
+    path = require('path'),
+    exec = require('child_process').exec;
+
+function generateTopic(args, file) {
+  return function () {
+    var cmd = './bin/vows' + ' -i ' + (args || '') +
+              ' ./test/fixtures/isolate/' + file,
+        options = {cwd: path.resolve(__dirname + '/../')},
+        callback = this.callback;
+
+    exec(cmd, options, function (err, stdout, stderr) {
+      callback(null, {
+        err: err,
+        stdout: stdout,
+        stderr: stderr
+      });
+    });
+  }
+};
+
+function assertExecOk(r) {
+  assert.isNull(r.err);
+}
+
+function assertExecNotOk(r) {
+  assert.isNotNull(r.err);
+}
+
+function parseResults(stdout) {
+  return stdout.split(/\n/g).map(function (s) {
+    if (!s) return;
+    return JSON.parse(s);
+  }).filter(function (s) {return s});
+}
+
+function assertResultTypePresent(results, type) {
+  assert.ok(results.some(function (result) {
+    return result[0] == type;
+  }));
+}
+
+function assertResultsFinish(results, expected) {
+  var finish = results[results.length - 1];
+  assert.equal(finish[0], 'finish');
+
+  finish = finish[1];
+
+  Object.keys(expected).forEach(function (key) {
+    assert.equal(finish[key], expected[key]);
+  });
+}
+
+vows.describe('vows/isolate').addBatch({
+  'Running vows with -i flag for test/fixtures/isolate/': {
+    'passing.js': {
+      'with default reporter': {
+        topic: generateTopic(null, 'passing.js'),
+        'should be ok': assertExecOk
+      },
+      'with json reporter': {
+        topic: generateTopic('--json', 'passing.js'),
+        'should be ok': assertExecOk,
+        'should have correct output': function (r) {
+          var results = parseResults(r.stdout)
+
+          assertResultTypePresent(results, 'subject');
+          assertResultTypePresent(results, 'end');
+
+          assertResultsFinish(results, {
+            total: 4,
+            honored: 4
+          });
+        }
+      }
+    },
+    'failing.js': {
+      'with json reporter': {
+        topic: generateTopic('--json', 'failing.js'),
+        'should be not ok': assertExecNotOk,
+        'should have correct output though': function (r) {
+          var results = parseResults(r.stdout);
+
+          assertResultsFinish(results, {
+            total: 4,
+            broken: 4
+          });
+        }
+      }
+    },
+    'stderr.js': {
+      'with json reporter': {
+        topic: generateTopic('--json', 'stderr.js'),
+        'should be ok': assertExecOk,
+        'should have stderr': function (r) {
+          assert.equal(r.stderr,
+                       ['oh no!', 'oh no!', 'oh no!', 'oh no!', ''].join('\n'));
+        },
+        'should have correct output': function (r) {
+          var results=  parseResults(r.stdout);
+
+          assertResultsFinish(results, {
+            total: 4,
+            honored: 4
+          });
+        }
+      }
+    },
+    'log.js': {
+      'with json reporter': {
+        topic: generateTopic('--json', 'log.js'),
+        'should be ok': assertExecOk,
+        'should have correct output': function (r) {
+          var results=  parseResults(r.stdout);
+
+          assertResultsFinish(results, {
+            total: 4,
+            honored: 4
+          });
+        }
+      }
+    },
+    'all tests (*)': {
+      'with json reporter': {
+        topic: generateTopic('--json', '*'),
+        'should be not ok': assertExecNotOk,
+        'should have correct output': function (r) {
+          var results=  parseResults(r.stdout);
+
+          assertResultsFinish(results, {
+            total: 16,
+            broken: 4,
+            honored: 12
+          });
+        }
+      }
+    }
+  }
+}).export(module);

data/server/node_modules/cradle/node_modules/vows/test/testInherit.js

@@ -0,0 +1,133 @@
+/*
+ * instanceof is a more complete check then .constructor ===
+ * 
+ * It works when using node's built-in util.inherits function
+ * and it also honors a class's entire ancestry
+ *
+ * Here I am only testing the change to vows in suite.js at line 147 to change
+ * the check from .constructor === to instanceof.  These tests should demonstrate
+ * that this change should work both cases.  For completness I also check
+ * the case when EventEmitter is an ancestor, not the parent Class.
+ * 
+ */
+var EventEmitter = process.EventEmitter,
+    util = require('util'),
+    vows = require('vows'),
+    assert = require('assert');
+    
+vows.describe('EventEmitters as a return value from a topic').addBatch({
+    'returning an EventEmitter' : {
+        topic : function () {
+            //Make an event emitter
+            var tmp = new EventEmitter();
+            //set it to emit success in a bit
+            setTimeout(function () {
+                //pass a value to make sure this all works
+                tmp.emit('success', 'I work');
+            }, 10);
+            
+            return tmp;
+        },
+        'will catch what I pass to success' : function (ret) {
+            assert.strictEqual(ret, 'I work');
+        }
+    },
+    'returning a class that uses util.inherit to inherit from EventEmitter' : {
+        topic : function () {
+            //Make a class that will util.inherit from EventEmitter
+            var Class = function () {
+                    EventEmitter.call(this);
+                },
+                tmp;
+                
+            //inherit from EventEmitter
+            util.inherits(Class, EventEmitter);
+            //Get a new one
+            tmp = new Class();
+            //set it to emit success in a bit
+            setTimeout(function () {
+                //pass a value to make sure this all works
+                tmp.emit('success', 'I work');
+            }, 10);
+            
+            return tmp;
+        },
+        'will catch what I pass to success' : function (ret) {
+            assert.strictEqual(ret, 'I work');
+        }
+    },
+    'returning a class that uses Class.prototype = new EventEmitter()' : {
+        topic : function () {
+            //Make a class that will inherit from EventEmitter
+            var Class = function () {}, tmp;
+            //inherit
+            Class.prototype = new EventEmitter();
+            //Get a new one
+            tmp = new Class();
+            //set it to emit success in a bit
+            setTimeout(function () {
+                //pass a value to make sure this all works
+                tmp.emit('success', 'I work');
+            }, 10);
+            
+            return tmp;
+        },
+        'will catch what I pass to success' : function (ret) {
+            assert.strictEqual(ret, 'I work');
+        }
+    },
+    'returning a class that uses util.inherit to inherit from a class that inherits from EventEmitter ' : {
+        topic : function () {
+            //Class1 inherits from EventEmitter
+            var Class1 = function () {
+                    var self = this;
+                    EventEmitter.call(self);
+                },
+                //Class2 inherits from Class1
+                Class2 = function () {
+                    Class1.call(this);
+                }, tmp;
+            //Inherit
+            util.inherits(Class1, EventEmitter);
+            util.inherits(Class2, Class1);
+            //Get a new one
+            tmp = new Class2();
+            //set it to emit success in a bit
+            setTimeout(function () {
+                //pass a value to make sure this all works
+                tmp.emit('success', 'I work');
+            },10);
+            
+            return tmp;
+        },
+        'will catch what I pass to success' : function (ret) {
+            assert.strictEqual(ret, 'I work');
+        }
+    },
+    'returning a class that uses Class2.prototype = new Class1() and Class1.prototype = new EventEmitter()' : {
+        topic : function () {
+            //Class1 will inherit from EventEmitter
+            var Class1 = function () {},
+                //Class2 will inherit from Class1
+                Class2 = function () {}, tmp;
+            //Inherit
+            Class1.prototype = new EventEmitter();
+            Class2.prototype = new Class1();
+            //Get a new one
+            tmp = new Class2();
+            //seit it to emit success in a bit
+            setTimeout(function () {
+                //pass a value to make sure this all works
+                tmp.emit('success', 'I work');
+            },10);
+            
+            return tmp;
+        },
+        'will catch what I pass to success' : function (ret) {
+            assert.strictEqual(ret, 'I work');
+        }
+    }
+}).export(module);
+
+
+

data/server/node_modules/cradle/node_modules/vows/test/vows-error-test.js

@@ -0,0 +1,51 @@
+var path   = require('path'),
+    events = require('events'),
+    assert = require('assert'),
+    fs     = require('fs'),
+    vows   = require('../lib/vows');
+    
+function doSomethingAsync(callback) {
+  	var err = null;
+  	var testValue = 'a';
+
+  	process.nextTick(function() {
+  		  callback(err, testValue);
+  	});
+}
+
+function doSomethingAsyncWithError(callback) {
+  	var err = true;
+  	var testValue = 'a';
+
+  	process.nextTick(function() {
+  		  callback(err, testValue);
+  	});
+}
+
+
+vows.describe('vows/error').addBatch({
+	'Generate success response to async function': {
+    		topic: function() {
+    			  doSomethingAsync(this.callback)
+    		},
+    		'Validate success': function(err, testValue) {
+    			  assert.ok(!err);
+    		},
+    		'Validate testValue': function(err, testValue) {
+    			  assert.equal(testValue, 'a');
+    		}
+  	},
+
+  	'Generate error response to async function': {
+    		topic: function() {
+    			  doSomethingAsyncWithError(this.callback)
+    		},
+    		'Validate error': function(err, testValue) {
+    			  assert.ok(err);
+    		},
+    		'Validate testValue': function(err, testValue) {
+    			  // This assertion fails. It shouldn't.
+    			  assert.equal(testValue, 'a');
+    		}
+  	}
+}).export(module)

data/server/node_modules/cradle/node_modules/vows/test/vows-test.js

@@ -0,0 +1,374 @@
+var path   = require('path'),
+    events = require('events'),
+    assert = require('assert'),
+    fs     = require('fs'),
+    vows   = require('../lib/vows');
+
+var api = vows.prepare({
+    get: function (id, callback) {
+        process.nextTick(function () { callback(null, id) });
+    },
+    version: function () { return '1.0' }
+}, ['get']);
+
+var promiser = function (val) {
+    return function () {
+        var promise = new(events.EventEmitter);
+        process.nextTick(function () { promise.emit('success', val) });
+        return promise;
+    }
+};
+
+vows.describe("Vows").addBatch({
+    "A context": {
+        topic: promiser("hello world"),
+
+        "with a nested context": {
+            topic: function (parent) {
+                this.state = 42;
+                return promiser(parent)();
+            },
+            "has access to the environment": function () {
+                assert.equal(this.state, 42);
+            },
+            "and a sub nested context": {
+                topic: function () {
+                    return this.state;
+                },
+                "has access to the parent environment": function (r) {
+                    assert.equal(r, 42);
+                    assert.equal(this.state, 42);
+                },
+                "has access to the parent context object": function (r) {
+                    assert.ok(Array.isArray(this.context.topics));
+                    assert.include(this.context.topics, "hello world");
+                }
+            }
+        }
+    },
+    "A nested context": {
+        topic: promiser(1),
+
+        ".": {
+            topic: function (a) { return promiser(2)() },
+
+            ".": {
+                topic: function (b, a) { return promiser(3)() },
+
+                ".": {
+                    topic: function (c, b, a) { return promiser([4, c, b, a])() },
+
+                    "should have access to the parent topics": function (topics) {
+                        assert.equal(topics.join(), [4, 3, 2, 1].join());
+                    }
+                },
+
+                "from": {
+                    topic: function (c, b, a) { return promiser([4, c, b, a])() },
+
+                    "the parent topics": function(topics) {
+                        assert.equal(topics.join(), [4, 3, 2, 1].join());
+                    }
+                }
+            }
+        }
+    },
+    "Nested contexts with callback-style async": {
+        topic: function () {
+            fs.stat(__dirname + '/vows-test.js', this.callback);
+        },
+        'after a successful `fs.stat`': {
+            topic: function (stat) {
+                fs.open(__dirname + '/vows-test.js', "r", stat.mode, this.callback);
+            },
+            'after a successful `fs.open`': {
+                topic: function (fd, stat) {
+                    fs.read(fd, stat.size, 0, "utf8", this.callback);
+                },
+                'after a successful `fs.read`': function (data) {
+                    assert.match (data, /after a successful `fs.read`/);
+                }
+            }
+        }
+    },
+    "A nested context with no topics": {
+        topic: 45,
+        ".": {
+            ".": {
+                "should pass the value down": function (topic) {
+                    assert.equal(topic, 45);
+                }
+            }
+        }
+    },
+    "A Nested context with topic gaps": {
+        topic: 45,
+        ".": {
+            ".": {
+                topic: 101,
+                ".": {
+                    ".": {
+                        topic: function (prev, prev2) {
+                            return this.context.topics.slice(0);
+                        },
+                        "should pass the topics down": function (topics) {
+                            assert.length(topics, 2);
+                            assert.equal(topics[0], 101);
+                            assert.equal(topics[1], 45);
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "A non-promise return value": {
+        topic: function () { return 1 },
+        "should be converted to a promise": function (val) {
+            assert.equal(val, 1);
+        }
+    },
+    "A 'prepared' interface": {
+        "with a wrapped function": {
+            topic: function () { return api.get(42) },
+            "should work as expected": function (val) {
+                assert.equal(val, 42);
+            }
+        },
+        "with a non-wrapped function": {
+            topic: function () { return api.version() },
+            "should work as expected": function (val) {
+                assert.equal(val, '1.0');
+            }
+        }
+    },
+    "A non-function topic": {
+        topic: 45,
+
+        "should work as expected": function (topic) {
+            assert.equal(topic, 45);
+        }
+    },
+    "A non-function topic with a falsy value": {
+        topic: 0,
+
+        "should work as expected": function (topic) {
+            assert.equal(topic, 0);
+        }
+    },
+    "A topic returning a function": {
+        topic: function () {
+            return function () { return 42 };
+        },
+
+        "should work as expected": function (topic) {
+            assert.isFunction(topic);
+            assert.equal(topic(), 42);
+        },
+        "in a sub-context": {
+            "should work as expected": function (topic) {
+                assert.isFunction(topic);
+                assert.equal(topic(), 42);
+            },
+        }
+    },
+    "A topic emitting an error": {
+        topic: function () {
+            var promise = new(events.EventEmitter);
+            process.nextTick(function () {
+                promise.emit("error", 404);
+            });
+            return promise;
+        },
+        "shouldn't raise an exception if the test expects it": function (e, res) {
+            assert.equal(e, 404);
+            assert.ok(! res);
+        }
+    },
+    "A topic not emitting an error": {
+        topic: function () {
+            var promise = new(events.EventEmitter);
+            process.nextTick(function () {
+                promise.emit("success", true);
+            });
+            return promise;
+        },
+        "should pass `null` as first argument, if the test is expecting an error": function (e, res) {
+            assert.strictEqual(e, null);
+            assert.equal(res, true);
+        },
+        "should pass the result as first argument if the test isn't expecting an error": function (res) {
+            assert.equal(res, true);
+        }
+    },
+    "A topic with callback-style async": {
+        "when successful": {
+            topic: function () {
+                var that = this;
+                process.nextTick(function () {
+                    that.callback(null, "OK");
+                });
+            },
+            "should work like an event-emitter": function (res) {
+                assert.equal(res, "OK");
+            },
+            "should assign `null` to the error argument": function (e, res) {
+                assert.strictEqual(e, null);
+                assert.equal(res, "OK");
+            }
+        },
+        "when unsuccessful": {
+            topic: function () {
+                function async(callback) {
+                    process.nextTick(function () {
+                        callback("ERROR");
+                    });
+                }
+                async(this.callback);
+            },
+            "should have a non-null error value": function (e, res) {
+                assert.equal(e, "ERROR");
+            },
+            "should work like an event-emitter": function (e, res) {
+                assert.equal(res, undefined);
+            }
+        },
+        "using this.callback synchronously": {
+            topic: function () {
+                this.callback(null, 'hello');
+            },
+            "should work the same as returning a value": function (res) {
+                assert.equal(res, 'hello');
+            }
+        },
+        "using this.callback with a user context": {
+            topic: function () {
+                this.callback.call({ boo: true }, null, 'hello');
+            },
+            "should give access to the user context": function (res) {
+                assert.isTrue(this.boo);
+            }
+        },
+        "passing this.callback to a function": {
+            topic: function () {
+                this.boo = true;
+                var async = function (callback) {
+                    callback(null);
+                };
+                async(this.callback);
+            },
+            "should give access to the topic context": function () {
+                assert.isTrue(this.boo);
+            }
+        },
+        "with multiple arguments": {
+            topic: function () {
+                this.callback(null, 1, 2, 3);
+            },
+            "should pass them to the vow": function (e, a, b, c) {
+                assert.strictEqual(e, null);
+                assert.strictEqual(a, 1);
+                assert.strictEqual(b, 2);
+                assert.strictEqual(c, 3);
+            },
+            "and a sub-topic": {
+                topic: function (a, b, c) {
+                    return [a, b, c];
+                },
+                "should receive them too": function (val) {
+                    assert.deepEqual(val, [1, 2, 3]);
+                }
+            }
+        }
+    }
+}).addBatch({
+    "A Sibling context": {
+        "'A', with `this.foo = true`": {
+            topic: function () {
+                this.foo = true;
+                return this;
+            },
+            "should have `this.foo` set to true": function (res) {
+                assert.equal(res.foo, true);
+            }
+        },
+        "'B', with nothing set": {
+            topic: function () {
+                return this;
+            },
+            "shouldn't have access to `this.foo`": function (e, res) {
+                assert.isUndefined(res.foo);
+            }
+        }
+    }
+}).addBatch({
+    "A 2nd batch": {
+        topic: function () {
+            var p = new(events.EventEmitter);
+            setTimeout(function () {
+                p.emit("success");
+            }, 100);
+            return p;
+        },
+        "should run after the first": function () {}
+    }
+}).addBatch({
+    "A 3rd batch": {
+        topic: true, "should run last": function () {}
+    }
+}).addBatch({}).export(module);
+
+vows.describe("Vows with a single batch", {
+    "This is a batch that's added as the optional parameter to describe()": {
+        topic: true,
+        "And a vow": function () {}
+    }
+}).export(module);
+
+vows.describe("Vows with multiple batches added as optional parameters", {
+    "First batch": {
+        topic: true,
+        "should be run first": function () {}
+    }
+}, {
+    "Second batch": {
+        topic: true,
+        "should be run second": function () {}
+    }
+}).export(module);
+
+vows.describe("Vows with teardowns").addBatch({
+    "A context": {
+        topic: function () {
+            return { flag: true };
+        },
+        "And a vow": function (topic) {
+            assert.isTrue(topic.flag);
+        },
+        "And another vow": function (topic) {
+            assert.isTrue(topic.flag);
+        },
+        "And a final vow": function (topic) {
+            assert.isTrue(topic.flag);
+        },
+        'subcontext': {
+          'nested': function (_, topic) {
+            assert.isTrue(topic.flag);
+          }
+        },
+        teardown: function (topic) {
+            topic.flag = false;
+        },
+        "with a subcontext" : {
+            topic: function (topic) {
+                var that = this;
+                process.nextTick(function () {
+                    that.callback(null, topic);
+                });
+            },
+            "Waits for the subcontext before teardown" : function(topic) {
+                assert.isTrue(topic.flag);
+            }
+        }
+    }
+}).export(module);
+