imf-data-nodejs-sdk
Version:
IMFData Cloudant Node.js SDK
825 lines (752 loc) • 23.6 kB
JavaScript
/**
* Copyright 2015 IBM Corp. All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var assert = require('assert');
var IMFData = require('../lib/imfdata.js');
var config = require('./utils/config.js');
var Errors = require('../lib/Errors.js');
var events = require('events');
describe('db', function() {
var data;
var db;
var doc_rev;
/**
* Gets data module and creates a database
*/
before(function(done) {
this.timeout(15000);
IMFData.initialize(config, function(err, imfdata) {
if (err) {
done(err);
} else {
data = imfdata;
data.db.create('testdb', function(err, body, headers) {
if (err) {
done(err);
} else {
db = data.use('testdb');
data.set_permissions({
identity: config.appId,
database: db.config.db,
access: 'admins'
}, function(err, response, headers) {
if (err) {
done(err);
} else {
done();
}
});
}
});
}
});
});
/**
* Cleans up database
*/
after(function(done) {
this.timeout(10000);
data.db.destroy('testdb', function(err, body, headers) {
if (err)
done(err);
else
done();
});
});
describe('.info([callback])', function() {
it('should successfully return database info', function(done) {
this.timeout(10000);
db.info(function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.replicate(target, [opts], [callback])', function() {
after(function(done) {
this.timeout(10000);
data.db.destroy('testreplicatedb', function(err, body, headers) {
if (err)
done(err);
else
done();
});
});
it('should successfully replicate database to target', function(done) {
this.timeout(10000);
db.replicate('testreplicatedb', {
create_target: true
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.compact([callback])', function() {
it('should produce error on database compaction', function(done) {
this.timeout(10000);
db.compact(function(err, response, headers) {
assert.ok(err);
done();
});
});
});
describe('.changes([params], [callback])', function() {
it('should successfully pull database changes', function(done) {
this.timeout(10000);
db.changes(function(err, body, headers) {
assert.ifError(err);
assert.ok(body);
assert.ok(headers);
done();
});
});
});
describe('.follow([params], [callback])', function() {
it('should successfully start database change feed', function(done) {
this.timeout(15000);
var feed = db.follow();
assert(feed instanceof events.EventEmitter);
feed.on('start', function() {
feed.stop();
});
feed.on('stop', function() {
done();
});
feed.on('error', function(err) {
done(err);
});
feed.follow();
});
it('should start database changes feed and listen for a change', function(done) {
this.timeout(15000);
var feed = db.follow();
assert(feed instanceof events.EventEmitter);
feed.on('start', function() {
});
feed.on('change', function(change) {
assert.ok(change);
feed.stop();
});
feed.on('stop', function() {
done();
});
feed.on('error', function(err) {
done(err);
});
feed.follow();
process.nextTick(function() {
db.insert({
foo: 'bar'
}, 'testfollow');
});
});
it('should create database changes feed with params and a callback and listen for a change', function(done) {
this.timeout(20000);
var feed = db.follow({
since: 'now'
}, function(err, change) {
assert.ifError(err);
assert.ok(change);
feed.stop();
});
assert(feed instanceof events.EventEmitter);
feed.on('stop', function() {
done();
});
setTimeout(function() {
db.insert({
foo: 'bar'
}, 'testfollow1');
}, 1000);
});
it('should create database changes feed with a callback and listen for a change', function(done) {
this.timeout(20000);
var feed = db.follow(function(err, change) {
assert.ifError(err);
assert.ok(change);
feed.stop();
});
assert(feed instanceof events.EventEmitter);
feed.on('stop', function() {
done();
});
setTimeout(function() {
db.insert({
foo: 'bar'
}, 'testfollow2');
}, 1000);
});
});
describe('.auth(user, pass, [callback])', function() {
it('should return cookie for registered cloudant user/api-key', function(done) {
this.timeout(10000);
db.auth(config.cloudant.credentials.username, config.cloudant.credentials.password, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(headers['set-cookie']);
done();
});
});
it('should return error for unregistered cloudant user/api-key', function(done) {
this.timeout(10000);
db.auth('fakeuser', 'fakepass', function(err, response, headers) {
assert.ok(err);
done();
});
});
});
describe('.session([callback])', function() {
it('should return current session', function(done) {
this.timeout(10000);
db.session(function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.insert(doc, doc_id, [callback])', function() {
it('should successfully insert a doc', function(done) {
this.timeout(10000);
db.insert({
test: 'foo'
}, 'test', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.get(doc_id, [params], [callback])', function() {
it('should successfully get a doc', function(done) {
this.timeout(10000);
db.get('test', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response._id);
assert.ok(response.test);
assert.equal(response.test, 'foo');
done();
});
});
});
describe('.head(doc_id, [callback])', function() {
it('should successfully return only the headers from getting a doc', function(done) {
this.timeout(10000);
db.head('test', function(err, response, headers) {
assert.ifError(err);
assert.equal(response, '');
assert.ok(headers);
done();
});
});
});
describe('.copy(src_doc, dest_doc, opts, [callback])', function() {
it('should successfully copy a doc to a new doc', function(done) {
this.timeout(10000);
db.copy('test', 'test1', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(response.rev);
doc_rev = response.rev;
assert.ok(headers);
done();
});
});
});
describe('.destroy(doc_id, rev, [callback])', function() {
it('should successfully delete a doc', function(done) {
this.timeout(10000);
db.destroy('test1', doc_rev, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.bulk(payload, [params], [callback])', function() {
it('should successfully bulk insert some new documents', function(done) {
this.timeout(10000);
var payload = {
docs: [{
_id: 'test1',
test: 'foo'
}, {
_id: 'test2',
test: 'bar'
}]
};
db.bulk(payload, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
done();
});
});
});
describe('.list([params], [callback])', function() {
it('should successfully list all documents in a database', function(done) {
this.timeout(10000);
var error = null;
db.list(function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.rows);
response.rows.forEach(function(doc) {
assert.ok(doc);
assert.ok(doc.id);
switch (true) {
case /test/.test(doc.id):
case /_design/.test(doc.id):
break;
default:
error = new Error("expected one of: 'test', 'test1', or 'test2' but recieved %s", doc.id);
return;
}
});
assert.ifError(error);
done();
});
});
});
describe('.fetch(doc_ids, [params], [callback])', function() {
it('should successfully fetch a set of documents', function(done) {
this.timeout(10000);
var error = null;
db.fetch({
keys: ['test', 'test1', 'test2']
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.rows);
response.rows.forEach(function(doc) {
assert.ok(doc);
assert.ok(doc.doc);
assert.ok(doc.id);
switch (doc.id) {
case 'test':
case 'test1':
case 'test2':
break;
default:
error = new Error("expected one of: 'test', 'test1', or 'test2' but recieved " + doc.id);
return;
}
});
assert.ifError(error);
done();
});
});
});
describe('.fetch_revs(doc_ids, [params], [callback])', function() {
it('should successfully fetch revisions for a set of documents', function(done) {
this.timeout(10000);
var error = null;
db.fetch_revs({
keys: ['test', 'test1', 'test2']
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.rows);
response.rows.forEach(function(doc) {
assert.ok(doc);
assert.ok(doc.id);
assert.ok(doc.value);
assert.ok(doc.value.rev);
switch (true) {
case /test/.test(doc.id):
break;
default:
error = new Error("expected one of: 'test', 'test1', or 'test2' but recieved " + doc.id);
return;
}
});
assert.ifError(error);
done();
});
});
});
describe('.config', function() {
it('should return the database config object', function(done) {
assert.ok(db.config);
assert.ok(db.config.url);
assert.ok(db.config.db);
done();
});
});
describe('.show(design_name, show_name, doc_id, [params], [callback])', function() {
before(function(done) {
this.timeout(10000);
db.insert({
_id: '_design/shows',
shows: {
test: function(doc, req) {
return doc.test;
}
}
}, '_design/shows', function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should successfully call a show function', function(done) {
this.timeout(10000);
db.show('shows', 'test', 'test', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.equal(response, 'foo');
assert.equal(headers['content-type'], 'text/html; charset=utf-8');
done();
});
});
});
describe('.atomic(design_name, update_name, doc_id, [body], [callback])', function() {
before(function(done) {
this.timeout(10000);
db.insert({
_id: '_design/updates',
updates: {
test: function(doc, req) {
if (!doc) {
if ('id' in req && req.id) {
return [{
_id: req.id,
count: 0
}, 'created'];
}
return [null, 'bar'];
}
doc.count++;
doc.edited_by = req.userCtx.name;
return [doc, 'updated'];
}
}
}, '_design/updates', function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should successfully call a design document\'s update function and create a new document', function(done) {
this.timeout(10000);
db.atomic('updates', 'test', 'testatomic', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.equal(response, 'created');
db.get('testatomic', function(err, response1, headers1) {
assert.ifError(err);
assert.ok(response1);
assert.ok(headers1);
assert.ok(response1._id);
assert.equal(response1.count, 0);
done();
});
});
});
});
describe('.updateWithHandler(design_name, update_name, doc_id, [body], [callback])', function() {
it('should be the same object as db.atomic()', function(done) {
assert.strictEqual(db.atomic, db.updateWithHandler);
done();
});
});
describe('.view(design_name, view_name, [params], [callback])', function() {
before(function(done) {
this.timeout(10000);
db.insert({
_id: '_design/views',
views: {
test: {
map: function(doc) {
if (doc.test) {
emit(doc._id, doc.test);
}
}
}
}
}, '_design/views', function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should successfully call a view', function(done) {
this.timeout(10000);
db.view('views', 'test', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.notEqual(response.total_rows, null);
assert.notEqual(response.offset, null);
assert.ok(response.rows);
response.rows.forEach(function(doc) {
assert.ok(doc.id);
assert.ok(doc.key);
assert.ok(doc.value);
});
done();
});
});
});
describe('.view_with_list(design_name, view_name, list_name, [params], [callback])', function() {
before(function(done) {
this.timeout(10000);
db.insert({
_id: '_design/lists',
views: {
test: {
map: function(doc) {
if (doc.test) {
emit(doc._id, doc.test);
}
}
}
},
lists: {
test: function(head, req) {
// specify our headers
start({
headers: {
"Content-Type": 'text/html; charset=utf-8'
}
});
// send the respond, line by line
send('<html><body><table>');
send('<tr><th>ID</th><th>Key</th><th>Value</th></tr>');
while ((row = getRow())) {
send(''.concat(
'<tr>',
'<td>' + toJSON(row.id) + '</td>',
'<td>' + toJSON(row.key) + '</td>',
'<td>' + toJSON(row.value) + '</td>',
'</tr>'
));
}
send('</table></body></html>');
}
}
}, '_design/lists', function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should successfully call a list function', function(done) {
this.timeout(10000);
db.view_with_list('lists', 'test', 'test', function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.equal(response, '<html><body><table><tr><th>ID</th><th>Key</th><th>Value</th></tr><tr><td>"test"</td><td>"test"</td><td>"foo"</td></tr><tr><td>"test1"</td><td>"test1"</td><td>"foo"</td></tr><tr><td>"test2"</td><td>"test2"</td><td>"bar"</td></tr></table></body></html>');
assert.equal(headers['content-type'], 'text/html; charset=utf-8');
done();
});
});
});
// TODO Check with Cloudant team if .spatial() should point to Cloudant Geo API
describe('.spatial(design_name, spatial_name, [params], [callback])', function() {
before(function(done) {
this.timeout(10000);
var payload = {
docs: [{
_id: 'geopoint',
geometry: {
coordinates: [-71.13687953,
42.34690635
],
type: "Point"
},
type: 'Feature'
}, {
_id: '_design/geo',
spatial: {
test: function(doc) {
if (doc.geometry) {
emit(doc.geometry, {
id: doc._id
});
}
}
},
indexes: {
geo_index: {
index: function(doc) {
if (doc.geometry && doc.geometry.coordinates) {
st_index(doc.geometry);
}
}
}
}
}]
};
db.bulk(payload, function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should return a callback error since spatial views are not supported', function(done) {
this.timeout(10000);
db.spatial('geo', 'test', function(err, response, headers) {
assert.ok(err);
done();
});
});
});
describe('.search(design_name, search_name, [params], [callback])', function() {
before(function(done) {
this.timeout(10000);
db.insert({
_id: '_design/search',
indexes: {
test: {
index: function(doc) {
index('default', doc._id);
if (doc.test) {
index('test', doc.test, {
store: 'yes'
});
}
}
}
}
}, '_design/search', function(err, response, headers) {
assert.ifError(err);
done();
});
});
it('should successfully query an index using the _search function', function(done) {
this.timeout(10000);
db.search('search', 'test', {
q: 'test:"foo"'
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.notEqual(response.total_rows, null);
assert.ok(response.bookmark);
assert.ok(response.rows);
response.rows.forEach(function(row) {
assert.ok(row);
assert.ok(row.id);
assert.ok(row.order);
assert.ok(row.fields);
assert.ok(row.fields.test);
assert.equal(row.fields.test, 'foo');
});
done();
});
});
});
describe('.view.compact(design_name, [callback])', function() {
it('should return an error', function(done) {
this.timeout(10000);
db.view.compact('views', function(err, response, headers) {
assert.ok(err);
done();
});
});
});
describe('.index(index, [callback])', function() {
it('should successfully create an index', function(done) {
this.timeout(10000);
db.index({
name: 'test-index',
ddoc: 'indexes',
type: 'json',
index: {
fields: ['test']
}
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.result);
assert.equal(response.result, 'created');
done();
});
});
});
describe('.index([callback])', function() {
it('should successfully return all indexes in a database', function(done) {
this.timeout(10000);
db.index(function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.indexes);
response.indexes.forEach(function(row) {
assert.notStrictEqual(row.ddoc, undefined);
assert.ok(row.name);
assert.ok(row.type);
assert.ok(row.def);
});
done();
});
});
});
describe('.find(cloudant_query, [callback])', function() {
it('should successfully query using an index', function(done) {
this.timeout(10000);
db.find({
selector: {
test: 'foo'
}
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.docs);
response.docs.forEach(function(row) {
assert.ok(row);
assert.ok(row._id);
assert.ok(row._rev);
assert.ok(row.test);
assert.equal(row.test, 'foo');
});
done();
});
});
});
describe('.index.del(index_info, [callback])', function() {
it('should successfully delete an index', function(done) {
this.timeout(10000);
db.index.del({
ddoc: '_design/indexes',
name: 'test-index'
}, function(err, response, headers) {
assert.ifError(err);
assert.ok(response);
assert.ok(headers);
assert.ok(response.ok);
assert.equal(response.ok, true);
assert.ok(headers['status-code']);
assert.equal(headers['status-code'], 200);
done();
});
});
});
});