Nemcio/NodeBB
1
0
Fork 0
mirror of https://github.com/NodeBB/NodeBB.git synced 2026-07-01 00:38:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename tests folder to test to follow standards

Browse Source
This commit is contained in:
HeeL
2016-09-28 09:56:41 +02:00
parent 157e9be6da
commit 4c6a75d85c
18 changed files with 1 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
test/database/hash.js Normal file
View File

@@ -0,0 +1,380 @@
'use strict';
/*global require, after, before*/
var async = require('async'),
assert = require('assert'),
db = require('../mocks/databasemock');
describe('Hash methods', function() {
var testData = {
name: 'baris',
lastname: 'usakli',
age: 99
};
beforeEach(function(done) {
db.setObject('hashTestObject', testData, done);
});
describe('setObject()', function() {
it('should create a object', function(done) {
db.setObject('testObject1', {foo: 'baris', bar: 99}, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('setObjectField()', function() {
it('should create a new object with field', function(done) {
db.setObjectField('testObject2', 'name', 'ginger', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
it('should add a new field to an object', function(done) {
db.setObjectField('testObject2', 'type', 'cat', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('getObject()', function() {
it('should return falsy if object does not exist', function(done) {
db.getObject('doesnotexist', function(err, data) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!data, false);
done();
});
});
it('should retrieve an object', function(done) {
db.getObject('hashTestObject', function(err, data) {
assert.equal(err, null);
assert.equal(data.name, testData.name);
assert.equal(data.age, testData.age);
assert.equal(data.lastname, 'usakli');
done();
});
});
});
describe('getObjects()', function() {
before(function(done) {
async.parallel([
async.apply(db.setObject, 'testObject4', {name: 'baris'}),
async.apply(db.setObjectField, 'testObject5', 'name', 'ginger')
], done);
});
it('should return 3 objects with correct data', function(done) {
db.getObjects(['testObject4', 'testObject5', 'doesnotexist'], function(err, objects) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(objects) && objects.length === 3, true);
assert.equal(objects[0].name, 'baris');
assert.equal(objects[1].name, 'ginger');
assert.equal(!!objects[2], false);
done();
});
});
});
describe('getObjectField()', function() {
it('should return falsy if object does not exist', function(done) {
db.getObjectField('doesnotexist', 'fieldName', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!value, false);
done();
});
});
it('should return falsy if field does not exist', function(done) {
db.getObjectField('hashTestObject', 'fieldName', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!value, false);
done();
});
});
it('should get an objects field', function(done) {
db.getObjectField('hashTestObject', 'lastname', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(value, 'usakli');
done();
});
});
});
describe('getObjectFields()', function() {
it('should return an object with falsy values', function(done) {
db.getObjectFields('doesnotexist', ['field1', 'field2'], function(err, object) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(typeof object, 'object');
assert.equal(!!object.field1, false);
assert.equal(!!object.field2, false);
done();
});
});
it('should return an object with correct fields', function(done) {
db.getObjectFields('hashTestObject', ['lastname', 'age', 'field1'], function(err, object) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(typeof object, 'object');
assert.equal(object.lastname, 'usakli');
assert.equal(object.age, 99);
assert.equal(!!object.field1, false);
done();
});
});
});
describe('getObjectsFields()', function() {
before(function(done) {
async.parallel([
async.apply(db.setObject, 'testObject8', {name: 'baris', age:99}),
async.apply(db.setObject, 'testObject9', {name: 'ginger', age: 3})
], done);
});
it('should return an array of objects with correct values', function(done) {
db.getObjectsFields(['testObject8', 'testObject9', 'doesnotexist'], ['name', 'age'], function(err, objects) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(objects), true);
assert.equal(objects.length, 3);
assert.equal(objects[0].name, 'baris');
assert.equal(objects[0].age, 99);
assert.equal(objects[1].name, 'ginger');
assert.equal(objects[1].age, 3);
assert.equal(!!objects[2].name, false);
done();
});
});
});
describe('getObjectKeys()', function() {
it('should return an empty array for a object that does not exist', function(done) {
db.getObjectKeys('doesnotexist', function(err, keys) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(keys) && keys.length === 0, true);
done();
});
});
it('should return an array of keys for the object\'s fields', function(done) {
db.getObjectKeys('hashTestObject', function(err, keys) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(keys) && keys.length === 3, true);
keys.forEach(function(key) {
assert.notEqual(['name', 'lastname', 'age'].indexOf(key), -1);
});
done();
});
});
});
describe('getObjectValues()', function() {
it('should return an empty array for a object that does not exist', function(done) {
db.getObjectValues('doesnotexist', function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(values) && values.length === 0, true);
done();
});
});
it('should return an array of values for the object\'s fields', function(done) {
db.getObjectValues('hashTestObject', function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(values) && values.length === 3, true);
assert.deepEqual(['baris', 'usakli', 99].sort(), values.sort());
done();
});
});
});
describe('isObjectField()', function() {
it('should return false if object does not exist', function(done) {
db.isObjectField('doesnotexist', 'field1', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(value, false);
done();
});
});
it('should return false if field does not exist', function(done) {
db.isObjectField('hashTestObject', 'field1', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(value, false);
done();
});
});
it('should return true if field exists', function(done) {
db.isObjectField('hashTestObject', 'name', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(value, true);
done();
});
});
});
describe('isObjectFields()', function() {
it('should return an array of false if object does not exist', function(done) {
db.isObjectFields('doesnotexist', ['field1', 'field2'], function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [false, false]);
done();
});
});
it('should return false if field does not exist', function(done) {
db.isObjectFields('hashTestObject', ['name', 'age', 'field1'], function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [true, true, false]);
done();
});
});
});
describe('deleteObjectField()', function() {
before(function(done) {
db.setObject('testObject10', {foo: 'bar', delete: 'this', delete1: 'this', delete2: 'this'}, done);
});
it('should delete an objects field', function(done) {
db.deleteObjectField('testObject10', 'delete', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.isObjectField('testObject10', 'delete', function(err, isField) {
assert.equal(err, null);
assert.equal(isField, false);
done();
});
});
});
it('should delete multiple fields of the object', function(done) {
db.deleteObjectFields('testObject10', ['delete1', 'delete2'], function(err) {
assert.ifError(err);
assert.equal(arguments.length, 1);
async.parallel({
delete1: async.apply(db.isObjectField, 'testObject10', 'delete1'),
delete2: async.apply(db.isObjectField, 'testObject10', 'delete2')
}, function(err, results) {
assert.ifError(err);
assert.equal(results.delete1, false);
assert.equal(results.delete2, false);
done();
});
});
});
});
describe('incrObjectField()', function() {
before(function(done) {
db.setObject('testObject11', {age: 99}, done);
});
it('should set an objects field to 1 if object does not exist', function(done) {
db.incrObjectField('testObject12', 'field1', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, 1);
done();
});
});
it('should increment an object fields by 1 and return it', function(done) {
db.incrObjectField('testObject11', 'age', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, 100);
done();
});
});
});
describe('decrObjectField()', function() {
before(function(done) {
db.setObject('testObject13', {age: 99}, done);
});
it('should set an objects field to -1 if object does not exist', function(done) {
db.decrObjectField('testObject14', 'field1', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, -1);
done();
});
});
it('should decrement an object fields by 1 and return it', function(done) {
db.decrObjectField('testObject13', 'age', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, 98);
done();
});
});
});
describe('incrObjectFieldBy()', function() {
before(function(done) {
db.setObject('testObject15', {age: 100}, done);
});
it('should set an objects field to 5 if object does not exist', function(done) {
db.incrObjectFieldBy('testObject16', 'field1', 5, function(err, newValue) {
assert.ifError(err);
assert.equal(arguments.length, 2);
assert.equal(newValue, 5);
done();
});
});
it('should increment an object fields by passed in value and return it', function(done) {
db.incrObjectFieldBy('testObject15', 'age', 11, function(err, newValue) {
assert.ifError(err);
assert.equal(arguments.length, 2);
assert.equal(newValue, 111);
done();
});
});
it('should increment an object fields by passed in value and return it', function(done) {
db.incrObjectFieldBy('testObject15', 'age', '11', function(err, newValue) {
assert.ifError(err);
assert.equal(newValue, 122);
done();
});
});
});
after(function(done) {
db.flushdb(done);
});
});

148
test/database/keys.js Normal file
View File

@@ -0,0 +1,148 @@
'use strict';
/*global require, after*/
var async = require('async'),
assert = require('assert'),
db = require('../mocks/databasemock');
describe('Key methods', function() {
beforeEach(function(done) {
db.set('testKey', 'testValue', done);
});
it('should set a key without error', function(done) {
db.set('testKey', 'testValue', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
it('should get a key without error', function(done) {
db.get('testKey', function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.strictEqual(value, 'testValue');
done();
});
});
it('should return true if key exist', function(done) {
db.exists('testKey', function(err, exists) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.strictEqual(exists, true);
done();
});
});
it('should return false if key does not exist', function(done) {
db.exists('doesnotexist', function(err, exists) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.strictEqual(exists, false);
done();
});
});
it('should delete a key without error', function(done) {
db.delete('testKey', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.get('testKey', function(err, value) {
assert.equal(err, null);
assert.equal(false, !!value);
done();
});
});
});
it('should return false if key was deleted', function(done) {
db.delete('testKey', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.exists('testKey', function(err, exists) {
assert.equal(err, null);
assert.strictEqual(exists, false);
done();
});
});
});
it('should delete all keys passed in', function(done) {
async.parallel([
function(next) {
db.set('key1', 'value1', next);
},
function(next) {
db.set('key2', 'value2', next);
}
], function(err) {
if (err) {
return done(err);
}
db.deleteAll(['key1', 'key2'], function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
async.parallel({
key1exists: function(next) {
db.exists('key1', next);
},
key2exists: function(next) {
db.exists('key2', next);
}
}, function(err, results) {
assert.equal(err, null);
assert.equal(results.key1exists, false);
assert.equal(results.key2exists, false);
done();
});
});
});
});
describe('increment', function() {
it('should initialize key to 1', function(done) {
db.increment('keyToIncrement', function(err, value) {
assert.equal(err, null);
assert.strictEqual(parseInt(value, 10), 1);
done();
});
});
it('should increment key to 2', function(done) {
db.increment('keyToIncrement', function(err, value) {
assert.equal(err, null);
assert.strictEqual(parseInt(value, 10), 2);
done();
});
});
});
describe('rename', function() {
it('should rename key to new name', function(done) {
db.set('keyOldName', 'renamedKeyValue', function(err) {
if (err) {
return done(err);
}
db.rename('keyOldName', 'keyNewName', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.get('keyNewName', function(err, value) {
assert.equal(err, null);
assert.equal(value, 'renamedKeyValue');
done();
});
});
});
});
});
after(function(done) {
db.flushdb(done);
});
});

166
test/database/list.js Normal file
View File

@@ -0,0 +1,166 @@
'use strict';
/*global require, after, before*/
var async = require('async'),
assert = require('assert'),
db = require('../mocks/databasemock');
describe('List methods', function() {
describe('listAppend()', function() {
it('should append to a list', function(done) {
db.listAppend('testList1', 5, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('listPrepend()', function() {
it('should prepend to a list', function(done) {
db.listPrepend('testList2', 3, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
it('should prepend 2 more elements to a list', function(done) {
async.series([
function(next) {
db.listPrepend('testList2', 2, next);
},
function(next) {
db.listPrepend('testList2', 1, next);
}
], function(err) {
assert.equal(err, null);
done();
});
});
});
describe('getListRange()', function() {
before(function(done) {
async.series([
function(next) {
db.listAppend('testList3', 7, next);
},
function(next) {
db.listPrepend('testList3', 3, next);
},
function(next) {
db.listAppend('testList4', 5, next);
}
], done);
});
it('should return an empty list', function(done) {
db.getListRange('doesnotexist', 0, -1, function(err, list) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(list), true);
assert.equal(list.length, 0);
done();
});
});
it('should return a list with one element', function(done) {
db.getListRange('testList4', 0, 0, function(err, list) {
assert.equal(err, null);
assert.equal(Array.isArray(list), true);
assert.equal(list[0], 5);
done();
});
});
it('should return a list with 2 elements 3, 7', function(done) {
db.getListRange('testList3', 0, -1, function(err, list) {
assert.equal(err, null);
assert.equal(Array.isArray(list), true);
assert.equal(list.length, 2);
assert.deepEqual(list, ['3', '7']);
done();
});
});
});
describe('listRemoveLast()', function() {
before(function(done) {
async.series([
function(next) {
db.listAppend('testList4', 12, next);
},
function(next) {
db.listPrepend('testList4', 9, next);
}
], done);
});
it('should remove the last element of list and return it', function(done) {
db.listRemoveLast('testList4', function(err, lastElement) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(lastElement, '12');
done();
});
});
});
describe('listRemoveAll()', function() {
before(function(done) {
async.series([
async.apply(db.listAppend, 'testList5', 1),
async.apply(db.listAppend, 'testList5', 1),
async.apply(db.listAppend, 'testList5', 1),
async.apply(db.listAppend, 'testList5', 2),
async.apply(db.listAppend, 'testList5', 5)
], done);
});
it('should remove all the matching elements of list', function(done) {
db.listRemoveAll('testList5', '1', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.getListRange('testList5', 0, -1, function(err, list) {
assert.equal(err, null);
assert.equal(Array.isArray(list), true);
assert.equal(list.length, 2);
assert.equal(list.indexOf('1'), -1);
done();
});
});
});
});
describe('listTrim()', function() {
it('should trim list to a certain range', function(done) {
var list = ['1', '2', '3', '4', '5'];
async.eachSeries(list, function(value, next) {
db.listAppend('testList6', value, next);
}, function(err) {
if (err) {
return done(err);
}
db.listTrim('testList6', 0, 2, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.getListRange('testList6', 0, -1, function(err, list) {
assert.equal(err, null);
assert.equal(list.length, 3);
assert.deepEqual(list, ['1', '2', '3']);
done();
});
});
});
});
});
after(function(done) {
db.flushdb(done);
});
});

235
test/database/sets.js Normal file
View File

@@ -0,0 +1,235 @@
'use strict';
/*global require, after, before*/
var async = require('async'),
assert = require('assert'),
db = require('../mocks/databasemock');
describe('Set methods', function() {
describe('setAdd()', function() {
it('should add to a set', function(done) {
db.setAdd('testSet1', 5, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
it('should add an array to a set', function(done) {
db.setAdd('testSet1', [1, 2, 3, 4], function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('getSetMembers()', function() {
before(function(done) {
db.setAdd('testSet2', [1,2,3,4,5], done);
});
it('should return an empty set', function(done) {
db.getSetMembers('doesnotexist', function(err, set) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(set), true);
assert.equal(set.length, 0);
done();
});
});
it('should return a set with all elements', function(done) {
db.getSetMembers('testSet2', function(err, set) {
assert.equal(err, null);
assert.equal(set.length, 5);
set.forEach(function(value) {
assert.notEqual(['1', '2', '3', '4', '5'].indexOf(value), -1);
});
done();
});
});
});
describe('setsAdd()', function() {
it('should add to multiple sets', function(done) {
db.setsAdd(['set1', 'set2'], 'value', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('getSetsMembers()', function() {
before(function(done) {
db.setsAdd(['set3', 'set4'], 'value', done);
});
it('should return members of two sets', function(done) {
db.getSetsMembers(['set3', 'set4'], function(err, sets) {
assert.equal(err, null);
assert.equal(Array.isArray(sets), true);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(sets[0]) && Array.isArray(sets[1]), true);
assert.strictEqual(sets[0][0], 'value');
assert.strictEqual(sets[1][0], 'value');
done();
});
});
});
describe('isSetMember()', function() {
before(function(done) {
db.setAdd('testSet3', 5, done);
});
it('should return false if element is not member of set', function(done) {
db.isSetMember('testSet3', 10, function(err, isMember) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(isMember, false);
done();
});
});
it('should return true if element is a member of set', function(done) {
db.isSetMember('testSet3', 5, function(err, isMember) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(isMember, true);
done();
});
});
});
describe('isSetMembers()', function() {
before(function(done) {
db.setAdd('testSet4', [1, 2, 3, 4, 5], done);
});
it('should return an array of booleans', function(done) {
db.isSetMembers('testSet4', ['1', '2', '10', '3'], function(err, members) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(members), true);
assert.deepEqual(members, [true, true, false, true]);
done();
});
});
});
describe('isMemberOfSets()', function() {
before(function(done) {
db.setsAdd(['set1', 'set2'], 'value', done);
});
it('should return an array of booleans', function(done) {
db.isMemberOfSets(['set1', 'testSet1', 'set2', 'doesnotexist'], 'value', function(err, members) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(members), true);
assert.deepEqual(members, [true, false, true, false]);
done();
});
});
});
describe('setCount()', function() {
before(function(done) {
db.setAdd('testSet5', [1,2,3,4,5], done);
});
it('should return the element count of set', function(done) {
db.setCount('testSet5', function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.strictEqual(count, 5);
done();
});
});
});
describe('setsCount()', function() {
before(function(done) {
async.parallel([
async.apply(db.setAdd, 'set5', [1,2,3,4,5]),
async.apply(db.setAdd, 'set6', 1),
async.apply(db.setAdd, 'set7', 2)
], done);
});
it('should return the element count of sets', function(done) {
db.setsCount(['set5', 'set6', 'set7', 'doesnotexist'], function(err, counts) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(Array.isArray(counts), true);
assert.deepEqual(counts, [5, 1, 1, 0]);
done();
});
});
});
describe('setRemove()', function() {
before(function(done) {
db.setAdd('testSet6', [1, 2], done);
});
it('should remove a element from set', function(done) {
db.setRemove('testSet6', '2', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.isSetMember('testSet6', '2', function(err, isMember) {
assert.equal(err, null);
assert.equal(isMember, false);
done();
});
});
});
});
describe('setsRemove()', function() {
before(function(done) {
db.setsAdd(['set1', 'set2'], 'value', done);
});
it('should remove a element from multiple sets', function(done) {
db.setsRemove(['set1', 'set2'], 'value', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.isMemberOfSets(['set1', 'set2'], 'value', function(err, members) {
assert.equal(err, null);
assert.deepEqual(members, [false, false]);
done();
});
});
});
});
describe('setRemoveRandom()', function() {
before(function(done) {
db.setAdd('testSet7', [1,2,3,4,5], done);
});
it('should remove a random element from set', function(done) {
db.setRemoveRandom('testSet7', function(err, element) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
db.isSetMember('testSet', element, function(err, ismember) {
assert.equal(err, null);
assert.equal(ismember, false);
done();
});
});
});
});
after(function(done) {
db.flushdb(done);
});
});

701
test/database/sorted.js Normal file
View File

@@ -0,0 +1,701 @@
'use strict';
/*global require, after, before*/
var async = require('async'),
assert = require('assert'),
db = require('../mocks/databasemock');
describe('Sorted Set methods', function() {
before(function(done) {
async.parallel([
function(next) {
db.sortedSetAdd('sortedSetTest1', [1, 2, 3], ['value1', 'value2', 'value3'], next);
},
function(next) {
db.sortedSetAdd('sortedSetTest2', [1, 4], ['value1', 'value4'], next);
},
function(next) {
db.sortedSetAdd('sortedSetTest3', [2, 4], ['value2', 'value4'], next);
}
], done);
});
describe('sortedSetAdd()', function() {
it('should add an element to a sorted set', function(done) {
db.sortedSetAdd('sorted1', 1, 'value1', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
it('should add two elements to a sorted set', function(done) {
db.sortedSetAdd('sorted2', [1, 2], ['value1', 'value2'], function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('sortedSetsAdd()', function() {
it('should add an element to two sorted sets', function(done) {
db.sortedSetsAdd(['sorted1', 'sorted2'], 3, 'value3', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
done();
});
});
});
describe('getSortedSetRange()', function() {
it('should return the lowest scored element', function(done) {
db.getSortedSetRange('sortedSetTest1', 0, 0, function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(value, ['value1']);
done();
});
});
it('should return elements sorted by score lowest to highest', function(done) {
db.getSortedSetRange('sortedSetTest1', 0, -1, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value1', 'value2', 'value3']);
done();
});
});
});
describe('getSortedSetRevRange()', function() {
it('should return the highest scored element', function(done) {
db.getSortedSetRevRange('sortedSetTest1', 0, 0, function(err, value) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(value, ['value3']);
done();
});
});
it('should return elements sorted by score highest to lowest', function(done) {
db.getSortedSetRevRange('sortedSetTest1', 0, -1, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value3', 'value2', 'value1']);
done();
});
});
});
describe('getSortedSetRangeWithScores()', function() {
it('should return array of elements sorted by score lowest to highest with scores', function(done) {
db.getSortedSetRangeWithScores('sortedSetTest1', 0, -1, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [{value: 'value1', score: 1}, {value: 'value2', score: 2}, {value: 'value3', score: 3}]);
done();
});
});
});
describe('getSortedSetRevRangeWithScores()', function() {
it('should return array of elements sorted by score highest to lowest with scores', function(done) {
db.getSortedSetRevRangeWithScores('sortedSetTest1', 0, -1, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [{value: 'value3', score: 3}, {value: 'value2', score: 2}, {value: 'value1', score: 1}]);
done();
});
});
});
describe('getSortedSetRangeByScore()', function() {
it('should get count elements with score between min max sorted by score lowest to highest', function(done) {
db.getSortedSetRangeByScore('sortedSetTest1', 0, -1, '-inf', 2, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value1', 'value2']);
done();
});
});
});
describe('getSortedSetRevRangeByScore()', function() {
it('should get count elements with score between max min sorted by score highest to lowest', function(done) {
db.getSortedSetRevRangeByScore('sortedSetTest1', 0, -1, '+inf', 2, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value3', 'value2']);
done();
});
});
});
describe('getSortedSetRangeByScoreWithScores()', function() {
it('should get count elements with score between min max sorted by score lowest to highest with scores', function(done) {
db.getSortedSetRangeByScoreWithScores('sortedSetTest1', 0, -1, '-inf', 2, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [{value: 'value1', score: 1}, {value: 'value2', score: 2}]);
done();
});
});
});
describe('getSortedSetRevRangeByScoreWithScores()', function() {
it('should get count elements with score between max min sorted by score highest to lowest', function(done) {
db.getSortedSetRevRangeByScoreWithScores('sortedSetTest1', 0, -1, '+inf', 2, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, [{value: 'value3', score: 3}, {value: 'value2', score: 2}]);
done();
});
});
});
describe('sortedSetCount()', function() {
it('should return 0 for a sorted set that does not exist', function(done) {
db.sortedSetCount('doesnotexist', 0, 10, function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(count, 0);
done();
});
});
it('should return number of elements between scores min max inclusive', function(done) {
db.sortedSetCount('sortedSetTest1', '-inf', 2, function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(count, 2);
done();
});
});
it('should return number of elements between scores -inf +inf inclusive', function(done) {
db.sortedSetCount('sortedSetTest1', '-inf', '+inf', function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(count, 3);
done();
});
});
});
describe('sortedSetCard()', function() {
it('should return 0 for a sorted set that does not exist', function(done) {
db.sortedSetCard('doesnotexist', function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(count, 0);
done();
});
});
it('should return number of elements in a sorted set', function(done) {
db.sortedSetCard('sortedSetTest1', function(err, count) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(count, 3);
done();
});
});
});
describe('sortedSetsCard()', function() {
it('should return the number of elements in sorted sets', function(done) {
db.sortedSetsCard(['sortedSetTest1', 'sortedSetTest2', 'doesnotexist'], function(err, counts) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(counts, [3, 2, 0]);
done();
});
});
});
describe('sortedSetRank()', function() {
it('should return falsy if sorted set does not exist', function(done) {
db.sortedSetRank('doesnotexist', 'value1', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!rank, false);
done();
});
});
it('should return falsy if element isnt in sorted set', function(done) {
db.sortedSetRank('sortedSetTest1', 'value5', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!rank, false);
done();
});
});
it('should return the rank of the element in the sorted set sorted by lowest to highest score', function(done) {
db.sortedSetRank('sortedSetTest1', 'value1', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(rank, 0);
done();
});
});
});
describe('sortedSetRevRank()', function() {
it('should return falsy if sorted set doesnot exist', function(done) {
db.sortedSetRevRank('doesnotexist', 'value1', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!rank, false);
done();
});
});
it('should return falsy if element isnt in sorted set', function(done) {
db.sortedSetRevRank('sortedSetTest1', 'value5', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!rank, false);
done();
});
});
it('should return the rank of the element in the sorted set sorted by highest to lowest score', function(done) {
db.sortedSetRevRank('sortedSetTest1', 'value1', function(err, rank) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(rank, 2);
done();
});
});
});
describe('sortedSetsRanks()', function() {
it('should return the ranks of values in sorted sets', function(done) {
db.sortedSetsRanks(['sortedSetTest1', 'sortedSetTest2'], ['value1', 'value4'], function(err, ranks) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(ranks, [0, 1]);
done();
});
});
});
describe('sortedSetRanks()', function() {
it('should return the ranks of values in a sorted set', function(done) {
db.sortedSetRanks('sortedSetTest1', ['value2', 'value1', 'value3', 'value4'], function(err, ranks) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(ranks, [1, 0, 2, null]);
done();
});
});
});
describe('sortedSetScore()', function() {
it('should return falsy if sorted set does not exist', function(done) {
db.sortedSetScore('doesnotexist', 'value1', function(err, score) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!score, false);
done();
});
});
it('should return falsy if element is not in sorted set', function(done) {
db.sortedSetScore('sortedSetTest1', 'value5', function(err, score) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(!!score, false);
done();
});
});
it('should return the score of an element', function(done) {
db.sortedSetScore('sortedSetTest1', 'value2', function(err, score) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(score, 2);
done();
});
});
});
describe('sortedSetsScore()', function() {
it('should return the scores of value in sorted sets', function(done) {
db.sortedSetsScore(['sortedSetTest1', 'sortedSetTest2', 'doesnotexist'], 'value1', function(err, scores) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(scores, [1, 1, null]);
done();
});
});
});
describe('sortedSetScores()', function() {
before(function(done) {
db.sortedSetAdd('zeroScore', 0, 'value1', done);
});
it('should return 0 if score is 0', function(done) {
db.sortedSetScores('zeroScore', ['value1'], function(err, scores) {
assert.ifError(err);
assert.equal(0, scores[0]);
done();
});
});
it('should return the scores of value in sorted sets', function(done) {
db.sortedSetScores('sortedSetTest1', ['value2', 'value1', 'doesnotexist'], function(err, scores) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(scores, [2, 1, null]);
done();
});
});
});
describe('isSortedSetMember()', function() {
before(function(done) {
db.sortedSetAdd('zeroscore', 0, 'itemwithzeroscore', done);
});
it('should return false if sorted set does not exist', function(done) {
db.isSortedSetMember('doesnotexist', 'value1', function(err, isMember) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(isMember, false);
done();
});
});
it('should return false if element is not in sorted set', function(done) {
db.isSortedSetMember('sorted2', 'value5', function(err, isMember) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(isMember, false);
done();
});
});
it('should return true if element is in sorted set', function(done) {
db.isSortedSetMember('sortedSetTest1', 'value2', function(err, isMember) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(isMember, true);
done();
});
});
it('should return true if element is in sorted set with score 0', function(done) {
db.isSortedSetMember('zeroscore', 'itemwithzeroscore', function(err, isMember) {
assert.ifError(err);
assert.deepEqual(isMember, true);
done();
});
});
});
describe('isSortedSetMembers()', function() {
it('should return an array of booleans indicating membership', function(done) {
db.isSortedSetMembers('sortedSetTest1', ['value1', 'value2', 'value5'], function(err, isMembers) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(isMembers, [true, true, false]);
done();
});
});
});
describe('isMemberOfSortedSets', function() {
it('should return true for members false for non members', function(done) {
db.isMemberOfSortedSets(['doesnotexist', 'sortedSetTest1', 'sortedSetTest2'], 'value2', function(err, isMembers) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(isMembers, [false, true, false]);
done();
});
});
});
describe('getSortedSetsMembers', function() {
it('should return members of multiple sorted sets', function(done) {
db.getSortedSetsMembers(['doesnotexist', 'sortedSetTest1'], function(err, sortedSets) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(sortedSets[0], []);
sortedSets[0].forEach(function(element) {
assert.notEqual(['value1', 'value2', 'value3'].indexOf(element), -1);
});
done();
});
});
});
describe('sortedSetUnionCard', function() {
it('should return the number of elements in the union', function(done) {
db.sortedSetUnionCard(['sortedSetTest2', 'sortedSetTest3'], function(err, count) {
assert.ifError(err);
assert.equal(count, 3);
done();
});
});
});
describe('getSortedSetUnion()', function() {
it('should return an array of values from both sorted sets sorted by scores lowest to highest', function(done) {
db.getSortedSetUnion({sets: ['sortedSetTest2', 'sortedSetTest3'], start: 0, stop: -1}, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value1', 'value2', 'value4']);
done();
});
});
});
describe('getSortedSetRevUnion()', function() {
it('should return an array of values from both sorted sets sorted by scores highest to lowest', function(done) {
db.getSortedSetRevUnion({sets: ['sortedSetTest2', 'sortedSetTest3'], start: 0, stop: -1}, function(err, values) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.deepEqual(values, ['value4', 'value2', 'value1']);
done();
});
});
});
describe('sortedSetIncrBy()', function() {
it('should create a sorted set with a field set to 1', function(done) {
db.sortedSetIncrBy('sortedIncr', 1, 'field1', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, 1);
db.sortedSetScore('sortedIncr', 'field1', function(err, score) {
assert.equal(err, null);
assert.equal(score, 1);
done();
});
});
});
it('should increment a field of a sorted set by 5', function(done) {
db.sortedSetIncrBy('sortedIncr', 5, 'field1', function(err, newValue) {
assert.equal(err, null);
assert.equal(arguments.length, 2);
assert.equal(newValue, 6);
db.sortedSetScore('sortedIncr', 'field1', function(err, score) {
assert.equal(err, null);
assert.equal(score, 6);
done();
});
});
});
});
describe('sortedSetRemove()', function() {
before(function(done) {
db.sortedSetAdd('sorted3', [1, 2], ['value1', 'value2'], done);
});
it('should remove an element from a sorted set', function(done) {
db.sortedSetRemove('sorted3', 'value2', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.isSortedSetMember('sorted3', 'value2', function(err, isMember) {
assert.equal(err, null);
assert.equal(isMember, false);
done();
});
});
});
});
describe('sortedSetsRemove()', function() {
before(function(done) {
async.parallel([
async.apply(db.sortedSetAdd, 'sorted4', [1,2], ['value1', 'value2']),
async.apply(db.sortedSetAdd, 'sorted5', [1,2], ['value1', 'value3']),
], done);
});
it('should remove element from multiple sorted sets', function(done) {
db.sortedSetsRemove(['sorted4', 'sorted5'], 'value1', function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.sortedSetsScore(['sorted4', 'sorted5'], 'value1', function(err, scores) {
assert.equal(err, null);
assert.deepEqual(scores, [null, null]);
done();
});
});
});
});
describe('sortedSetsRemoveRangeByScore()', function() {
before(function(done) {
db.sortedSetAdd('sorted6', [1,2,3,4,5], ['value1','value2','value3','value4','value5'], done);
});
it('should remove elements with scores between min max inclusive', function(done) {
db.sortedSetsRemoveRangeByScore(['sorted6'], 4, 5, function(err) {
assert.equal(err, null);
assert.equal(arguments.length, 1);
db.getSortedSetRange('sorted6', 0, -1, function(err, values) {
assert.equal(err, null);
assert.deepEqual(values, ['value1', 'value2', 'value3']);
done();
});
});
});
});
describe('getSortedSetIntersect', function() {
before(function(done) {
async.parallel([
function(next) {
db.sortedSetAdd('interSet1', [1,2,3], ['value1', 'value2', 'value3'], next);
},
function(next) {
db.sortedSetAdd('interSet2', [4,5,6], ['value2', 'value3', 'value5'], next);
}
], done);
});
it('should return the intersection of two sets', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet2'],
start: 0,
stop: -1
}, function(err, data) {
assert.ifError(err);
assert.deepEqual(['value2', 'value3'], data);
done();
});
});
it('should return the intersection of two sets with scores', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet2'],
start: 0,
stop: -1,
withScores: true
}, function(err, data) {
assert.ifError(err);
assert.deepEqual([{value: 'value2', score: 6}, {value: 'value3', score: 8}], data);
done();
});
});
it('should return the intersection of two sets with scores aggregate MIN', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet2'],
start: 0,
stop: -1,
withScores: true,
aggregate: 'MIN'
}, function(err, data) {
assert.ifError(err);
assert.deepEqual([{value: 'value2', score: 2}, {value: 'value3', score: 3}], data);
done();
});
});
it('should return the intersection of two sets with scores aggregate MAX', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet2'],
start: 0,
stop: -1,
withScores: true,
aggregate: 'MAX'
}, function(err, data) {
assert.ifError(err);
assert.deepEqual([{value: 'value2', score: 4}, {value: 'value3', score: 5}], data);
done();
});
});
it('should return the intersection with scores modified by weights', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet2'],
start: 0,
stop: -1,
withScores: true,
weights: [1, 0.5]
}, function(err, data) {
assert.ifError(err);
assert.deepEqual([{value: 'value2', score: 4}, {value: 'value3', score: 5.5}], data);
done();
});
});
it('should return empty array if sets do not exist', function(done) {
db.getSortedSetIntersect({
sets: ['interSet10', 'interSet12'],
start: 0,
stop: -1
}, function(err, data) {
assert.ifError(err);
assert.equal(data.length, 0);
done();
});
});
it('should return empty array if one set does not exist', function(done) {
db.getSortedSetIntersect({
sets: ['interSet1', 'interSet12'],
start: 0,
stop: -1
}, function(err, data) {
assert.ifError(err);
assert.equal(data.length, 0);
done();
});
});
});
describe('sortedSetIntersectCard', function() {
before(function(done) {
async.parallel([
function(next) {
db.sortedSetAdd('interCard1', [0, 0, 0], ['value1', 'value2', 'value3'], next);
},
function(next) {
db.sortedSetAdd('interCard2', [0, 0, 0], ['value2', 'value3', 'value4'], next);
},
function(next) {
db.sortedSetAdd('interCard3', [0, 0, 0], ['value3', 'value4', 'value5'], next);
},
function(next) {
db.sortedSetAdd('interCard4', [0, 0, 0], ['value4', 'value5', 'value6'], next);
}
], done);
});
it('should return # of elements in intersection', function(done) {
db.sortedSetIntersectCard(['interCard1', 'interCard2', 'interCard3'], function(err, count) {
assert.ifError(err);
assert.strictEqual(count, 1);
done();
});
});
it('should return 0 if intersection is empty', function(done) {
db.sortedSetIntersectCard(['interCard1', 'interCard4'], function(err, count) {
assert.ifError(err);
assert.strictEqual(count, 0);
done();
});
});
});
after(function(done) {
db.flushdb(done);
});
});