vulcan 0.3.0 → 0.4.0

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

@@ -1,135 +0,0 @@
-var vows = require('../lib/vows');
-var assert = require('assert');
-
-vows.describe('vows/assert').addBatch({
-    "The Assertion module": {
-        topic: require('assert'),
-
-        "`equal`": function (assert) {
-            assert.equal("hello world", "hello world");
-            assert.equal(1, true);
-        },
-        "`match`": function (assert) {
-            assert.match("hello world", /^[a-z]+ [a-z]+$/);
-        },
-        "`length`": function (assert) {
-            assert.length("hello world", 11);
-            assert.length([1, 2, 3], 3);
-        },
-        "`isDefined`": function (assert) {
-            assert.isDefined(null);
-            assertError(assert.isDefined, undefined);
-        },
-        "`include`": function (assert) {
-            assert.include("hello world", "world");
-            assert.include([0, 42, 0],    42);
-            assert.include({goo:true},    'goo');
-        },
-        "`deepInclude`": function (assert) {
-            assert.deepInclude([{a:'b'},{c:'d'}], {a:'b'});
-            assert.deepInclude("hello world", "world");
-            assert.deepInclude({goo:true},    'goo');
-        },
-        "`typeOf`": function (assert) {
-            assert.typeOf('goo', 'string');
-            assert.typeOf(42,    'number');
-            assert.typeOf([],    'array');
-            assert.typeOf({},    'object');
-            assert.typeOf(false, 'boolean');
-        },
-        "`instanceOf`": function (assert) {
-            assert.instanceOf([], Array);
-            assert.instanceOf(function () {}, Function);
-        },
-        "`isArray`": function (assert) {
-            assert.isArray([]);
-            assertError(assert.isArray, {});
-        },
-        "`isString`": function (assert) {
-            assert.isString("");
-        },
-        "`isObject`": function (assert) {
-            assert.isObject({});
-            assertError(assert.isObject, []);
-        },
-        "`isNumber`": function (assert) {
-            assert.isNumber(0);
-        },
-        "`isBoolean`": function (assert){
-            assert.isBoolean(true);
-            assert.isBoolean(false);
-            assertError(assert.isBoolean, 0);
-        },
-        "`isNan`": function (assert) {
-            assert.isNaN(0/0);
-        },
-        "`isTrue`": function (assert) {
-            assert.isTrue(true);
-            assertError(assert.isTrue, 1);
-        },
-        "`isFalse`": function (assert) {
-            assert.isFalse(false);
-            assertError(assert.isFalse, 0);
-        },
-        "`isZero`": function (assert) {
-            assert.isZero(0);
-            assertError(assert.isZero, null);
-        },
-        "`isNotZero`": function (assert) {
-            assert.isNotZero(1);
-        },
-        "`isUndefined`": function (assert) {
-            assert.isUndefined(undefined);
-            assertError(assert.isUndefined, null);
-        },
-        "`isDefined`": function (assert) {
-            assert.isDefined(null);
-            assertError(assert.isDefined, undefined);
-        },
-        "`isNull`": function (assert) {
-            assert.isNull(null);
-            assertError(assert.isNull, 0);
-            assertError(assert.isNull, undefined);
-        },
-        "`isNotNull`": function (assert) {
-            assert.isNotNull(0);
-        },
-        "`greater` and `lesser`": function (assert) {
-            assert.greater(5, 4);
-            assert.lesser(4, 5);
-        },
-        "`inDelta`": function (assert) {
-            assert.inDelta(42, 40, 5);
-            assert.inDelta(42, 40, 2);
-            assert.inDelta(42, 42, 0);
-            assert.inDelta(3.1, 3.0, 0.2);
-            assertError(assert.inDelta, [42, 40, 1]);
-        },
-        "`isEmpty`": function (assert) {
-            assert.isEmpty({});
-            assert.isEmpty([]);
-            assert.isEmpty("");
-        },
-        "`isNotEmpty`": function (assert) {
-            assert.isNotEmpty({goo:true});
-            assert.isNotEmpty([1]);
-            assert.isNotEmpty(" ");
-            assertError(assert.isNotEmpty, {});
-            assertError(assert.isNotEmpty, []);
-            assertError(assert.isNotEmpty, "");
-        }
-    }
-}).export(module);
-
-function assertError(assertion, args, fail) {
-    if (!Array.isArray(args)) { args = [args]; }
-    try {
-        assertion.apply(null, args);
-        fail = true;
-    } catch (e) {/* Success */}
-
-    fail && assert.fail(args.join(' '), assert.AssertionError,
-                               "expected an AssertionError for {actual}",
-                               "assertError", assertError);
-}
-

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)