vulcan 0.6.1 → 0.7.0

data/server/node_modules/cradle/test/database-cache-test.js

@@ -0,0 +1,132 @@
+var path = require('path'),
+    assert = require('assert'),
+    events = require('events'),
+    http = require('http'),
+    fs = require('fs'),
+    vows = require('vows');
+
+function status(code) {
+    return function (e, res) {
+        assert.ok(res || e);
+        assert.equal((res || e).headers.status || (res || e).status, code);
+    };
+}
+
+var cradle = require('../lib/cradle');
+
+vows.describe('cradle/database/cache').addBatch({
+    "A Cradle connection (cache)": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, { cache: true }).database('pigs');
+        },
+        "save()": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.save('bob', {ears: true}, function (e, res) {
+                    promise.emit("success", db);
+                });
+                return promise;
+            },
+            "should write through the cache": function (db) {
+                assert.ok(db.cache.has('bob'));
+                assert.ok(db.cache.get('bob')._rev);
+            },
+            "when fetching the cached document": {
+                topic: function (db) {
+                    db.get('bob', this.callback)
+                },
+                "document contains _id": function (e, doc) {
+                    assert.equal(doc._id, 'bob');
+                }
+            },
+            "and": {
+                topic: function (db) {
+                    var promise = new(events.EventEmitter);
+                    db.save('bob', {size: 12}, function (e, res) {
+                        promise.emit('success', res, db.cache.get('bob'));
+                    });
+                    return promise;
+                },
+                "return a 201": status(201),
+                "allow an overwrite": function (res) {
+                   assert.match(res.rev, /^2/);
+                },
+                "caches the updated document": function (e, res, doc) {
+                    assert.ok(doc);
+                    assert.equal(doc.size, 12);
+                    assert.isUndefined(doc.ears);
+                }
+            }
+        },
+        "save() with / in id": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.save('bob/someotherdoc', {size: 12}, function (e, res) {
+                    promise.emit('success', res, db.cache.get('bob/someotherdoc'));
+                });
+                return promise;
+            },
+            "return a 201": status(201),
+            "allow an overwrite": function (res) {
+               assert.match(res.rev, /^1/);
+            },
+            "caches the updated document": function (e, res, doc) {
+                assert.ok(doc);
+                assert.equal(doc.size, 12);
+            }
+        },
+        "merge()": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.save('billy', {ears: true}, function (e, res) {
+                    promise.emit("success", db);
+                });
+                return promise;
+            },
+            "should write through the cache": function (db) {
+                assert.ok(db.cache.has('billy'));
+                assert.ok(db.cache.get('billy')._rev);
+            },
+            "and": {
+                topic: function (db) {
+                    var promise = new(events.EventEmitter);
+                    db.merge('billy', {size: 12}, function (e, res) {
+                        promise.emit('success', res, db.cache.get('billy'));
+                    });
+                    return promise;
+                },
+                "return a 201": status(201),
+                "allow an overwrite": function (res) {
+                   assert.match(res.rev, /^2/);
+                },
+                "caches the updated document": function (e, res, doc) {
+                    assert.ok(doc);
+                    assert.equal(doc.size, 12);
+                    assert.equal(doc.ears, true);
+                }
+            }
+        },
+        "remove()": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.save('bruno', {}, function (e, res) {
+                    promise.emit("success", db);
+                });
+                return promise;
+            },
+            "shouldn't ask for a revision": {
+                topic: function (db) {
+                    var promise = new(events.EventEmitter);
+                    db.remove('bruno', function () { promise.emit('success', db) });
+                    return promise;
+                },
+                "and should purge the cache": function (db) {
+                    assert.equal(db.cache.has('bruno'), false);
+                },
+                "and raise an exception if you use remove() without a rev": function (db) {
+                    //assert.throws(db.remove('bruno'), Error);
+                }
+            }
+        }
+    }
+}).export(module);

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

@@ -0,0 +1,219 @@
+var path = require('path'),
+    assert = require('assert'),
+    events = require('events'),
+    http = require('http'),
+    fs = require('fs'),
+    vows = require('vows');
+
+function status(code) {
+    return function (e, res) {
+        assert.ok(res || e);
+        assert.equal((res || e).headers.status || (res || e).status, code);
+    };
+}
+
+function shouldQueryCouch(name) {
+    return {
+        topic: function (c) { return c.database(name) },
+
+        "info()": {
+            topic: function (db) {
+                db.info(this.callback);
+            },
+            "returns a 200": status(200),
+            "returns database info": function (info) {
+                assert.equal(info['db_name'], name);
+            }
+        },
+        "fetching a document by id (GET)": {
+            topic: function (db) { db.get('mike', this.callback) },
+            "returns a 200": status(200),
+            "returns the document": function (res) {
+                assert.equal(res.id, 'mike');
+            },
+            "when not found": {
+                topic: function (_, db) { db.get('tyler', this.callback) },
+                "returns a 404": status(404),
+                "returns the error": function (err, res) {
+                    assert.isObject(err);
+                    assert.isObject(err.headers);
+                    assert.isUndefined(res);
+                },
+            }
+        },
+        "head()": {
+            topic: function (db) { db.head('mike', this.callback) },
+            "returns the headers": function (res) {
+                assert.match(res.etag, /^"\d-[a-z0-9]+"$/);
+            }
+        },
+        "save()": {
+            "with an id & doc": {
+                topic: function (db) {
+                    db.save('joe', {gender: 'male'}, this.callback);
+                },
+                "creates a new document (201)": status(201),
+                "returns the revision": function (res) {
+                    assert.ok(res.rev);
+                }
+            },
+            "with a doc containing non-ASCII characters": {
+                topic: function (db) {
+                    db.save('john', {umlauts: 'äöü'}, this.callback);
+                },
+                "creates a new document (201)": status(201)
+            },
+            "with a large doc": {
+                topic: function (db) {
+                    var text = (function (s) {
+                        for (var i = 0; i < 18; i++) { s += s }
+                        return s;
+                    })('blah');
+
+                    db.save('large-bob', {
+                        gender: 'male',
+                        speech: text
+                    }, this.callback);
+                },
+                "creates a new document (201)": status(201)
+            },
+            "with a '_design' id": {
+                topic: function (db) {
+                    db.save('_design/horses', {
+                        all: {
+                            map: function (doc) {
+                                if (doc.speed == 72) emit(null, doc);
+                            }
+                        }
+                    }, this.callback);
+                },
+                "creates a doc (201)": status(201),
+                "returns the revision": function (res) {
+                    assert.ok(res.rev);
+                },
+                "creates a design doc": {
+                    topic: function (res, db) {
+                        db.view('horses/all', this.callback);
+                    },
+                    "which can be queried": status(200)
+                }
+            },
+            "without an id (POST)": {},
+        },
+        "calling save() with an array": {
+            topic: function (db) {
+                db.save([{_id: 'tom'}, {_id: 'flint'}], this.callback);
+            },
+            "returns an array of document ids and revs": function (res) {
+                assert.equal(res[0].id, 'tom');
+                assert.equal(res[1].id, 'flint');
+            },
+            "should bulk insert the documents": {
+                topic: function (res, db) {
+                    var promise = new(events.EventEmitter);
+                    db.get('tom', function (e, tom) {
+                        db.get('flint', function (e, flint) {
+                            promise.emit('success', tom, flint);
+                        });
+                    });
+                    return promise;
+                },
+                "which can then be retrieved": function (e, tom, flint) {
+                    assert.ok(tom._id);
+                    assert.ok(flint._id);
+                }
+            }
+        },
+        "getting all documents": {
+            "with no options": {
+                topic: function (db) {
+                    db.all(this.callback);
+                },
+                "returns a 200": status(200),
+                "returns a list of all docs": function (res) {
+                    assert.isArray(res);
+                    assert.isNumber(res.total_rows);
+                    assert.isNumber(res.offset);
+                    assert.isArray(res.rows);
+                },
+                "which can be iterated upon": function (res) {
+                    assert.isFunction(res.forEach);
+                }
+            },
+            "with { limit: 1 }": {
+                topic: function (db) {
+                    db.all({ limit: 1 }, this.callback);
+                },
+                "returns a 200": status(200),
+                "returns a list of all docs": function (res) {
+                    assert.isArray(res);
+                    assert.isNumber(res.total_rows);
+                    assert.isNumber(res.offset);
+                    assert.isArray(res.rows);
+                    assert.lengthOf(res.rows, 1);
+                },
+                "which can be iterated upon": function (res) {
+                    assert.isFunction(res.forEach);
+                }
+            },
+            "with { keys: ['mike'] }": {
+                topic: function (db) {
+                    db.all({ keys: ['mike'] }, this.callback);
+                },
+                "returns a 200": status(200),
+                "returns a list of all docs": function (res) {
+                    assert.isArray(res);
+                    assert.isNumber(res.total_rows);
+                    assert.isNumber(res.offset);
+                    assert.isArray(res.rows);
+                    assert.lengthOf(res.rows, 1);
+                },
+                "which can be iterated upon": function (res) {
+                    assert.isFunction(res.forEach);
+                }
+            }
+        },
+        "updating a document (PUT)": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.get('mike', function (err, doc) {
+                    db.save('mike', doc.rev,
+                        {color: doc.color, age: 13}, function (err, res) {
+                        if (! err) promise.emit('success', res, db);
+                        else promise.emit('error', res);
+                    });
+                });
+                return promise;
+            },
+            "returns a 201": status(201),
+            "returns the revision": function (res) {
+                assert.ok(res.rev);
+                assert.match(res.rev, /^2/);
+            },
+        },
+        "deleting a document (DELETE)": {
+            topic: function (db) {
+                var promise = new(events.EventEmitter);
+                db.get('deleteme', function (e, res) {
+                    db.remove('deleteme', res.rev, function (e, res) {
+                        promise.emit('success', res);
+                    });
+                });
+                return promise;
+            },
+            "returns a 200": status(200)
+        }
+    }
+}
+
+var cradle = require('../lib/cradle');
+
+vows.describe('cradle/database').addBatch({
+    "Connection": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false});
+        },
+        "database() with no /": shouldQueryCouch('pigs'),
+        "database() with /": shouldQueryCouch('animals/snorlax')
+    }
+}).export(module);

data/server/node_modules/cradle/test/database-view-test.js

@@ -0,0 +1,141 @@
+var path = require('path'),
+    assert = require('assert'),
+    events = require('events'),
+    http = require('http'),
+    fs = require('fs'),
+    vows = require('vows');
+
+function status(code) {
+    return function (e, res) {
+        assert.ok(res || e);
+        assert.equal((res || e).headers.status || (res || e).status, code);
+    };
+}
+
+function shouldQueryView(topic, rows, total) {
+    return {
+        topic: topic,
+        "returns a 200": status(200),
+        "returns view results": function (res) {
+            assert.isArray(res.rows);
+            assert.equal(res.rows.length, rows.length);
+            assert.equal(res.total_rows, total || rows.length);
+        },
+        "returns an iterable object with key/val pairs": function (res) {
+            assert.isArray(res);
+            assert.lengthOf(res, rows.length);
+            res.forEach(function (k, v) {
+                assert.isObject(v);
+                assert.isString(k);
+                assert.notEqual(rows.indexOf(k), -1);
+            });
+        },
+    }
+}
+
+var cradle = require('../lib/cradle');
+
+vows.describe('cradle/database/view').addBatch({
+    "Database": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "querying a view": {
+            "with no options": shouldQueryView(
+                function (db) {
+                    db.view('pigs/all', this.callback);
+                },
+                ['bill', 'mike', 'alex']
+            ),
+            "with a single key": shouldQueryView(
+                function (db) {
+                    db.view('pigs/all', { key: 'bill' }, this.callback);
+                },
+                ['bill'],
+                3
+            ),
+            "with a startKey and endKey": shouldQueryView(
+                function (db) {
+                    db.view('pigs/all', { startkey: 'b', endkey: 'r' }, this.callback);
+                },
+                ['bill', 'mike'],
+                3
+            ),
+            "with keys": shouldQueryView(
+                function (db) {
+                    db.view('pigs/all', { keys: ['mike', 'bill'] }, this.callback);
+                },
+                ['mike', 'bill'],
+                3
+            ),
+            "with a `keys` body": shouldQueryView(
+                function (db) {
+                    db.view('pigs/all', { body: { keys: ['mike', 'bill'] } }, this.callback);
+                },
+                ['mike', 'bill'],
+                3
+            )
+        },
+        // same as the above test, but with a temporary view
+        "querying a temporary view": {
+            "with no options": shouldQueryView(
+                function (db) {
+                    db.temporaryView({
+                        map: function (doc) {
+                            if (doc.color) emit(doc._id, doc);
+                        }
+                    }, this.callback);
+                },
+                ['mike', 'bill', 'alex']
+            )
+        },
+        "cleaning up a view with viewCleanup()": {
+            topic: function (db) {
+                db.viewCleanup(this.callback);
+            },
+            "returns a 202": status(202),
+            "no error is thrown and we get ok response": function (e, res) {
+                assert.ok(!e);
+                assert.ok(res && res.ok && res.ok === true);
+            }
+        }
+    }
+}).addBatch({
+    "Database": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "querying a temporary view": {
+            "with a single key": shouldQueryView(
+                function (db) {
+                    db.temporaryView({
+                        map: function (doc) {
+                            if (doc.color) emit(doc._id, doc);
+                        }
+                    }, { key: 'mike' }, this.callback);
+                },
+                ['mike'],
+                3
+            )
+        }
+    }
+}).addBatch({
+    "Database": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "querying a temporary view": {
+            "with a startKey and endKey": shouldQueryView(
+                function (db) {
+                    db.temporaryView({
+                        map: function (doc) {
+                            if (doc.color) emit(doc._id, doc);
+                        }
+                    }, { startkey: 'b', endkey: 'zzzz' }, this.callback);
+                },
+                ['mike', 'bill'],
+                3
+            )
+        }
+    }
+}).export(module);