vulcan 0.1.6 → 0.2.0

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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,133 +0,0 @@
-/*
- * 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

@@ -1,51 +0,0 @@
-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

@@ -1,374 +0,0 @@
-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);
-