redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-07 13:22:56 +03:00
Code Activity

test fixup

Browse Source
This commit is contained in:
Ruben Bridgewater
2017-05-06 08:16:19 +02:00
parent f1a7bcd735
commit b2613b2270
106 changed files with 2900 additions and 2967 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
test/auth.spec.js
View File

@@ -1,30 +1,30 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
// TODO: Fix redis process spawn on windows
// TODO: Fix redis process spawn on windows
if (process.platform !== 'win32') {
describe('client authentication', function () {
before(function (done) {
helper.stopRedis(function () {
describe('client authentication', () => {
before((done) => {
helper.stopRedis(() => {
helper.startRedis('./conf/password.conf', done)
})
})
helper.allTests({
allConnections: true
}, function (ip, args) {
describe('using ' + ip, function () {
var auth = 'porkchopsandwiches'
var client = null
}, (ip, args) => {
describe(`using ${ip}`, () => {
const auth = 'porkchopsandwiches'
let client = null
beforeEach(function () {
beforeEach(() => {
client = null
})
afterEach(function () {
afterEach(() => {
// Explicitly ignore still running commands
// The ready command could still be running
client.end(false)
@@ -34,7 +34,7 @@ if (process.platform !== 'win32') {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient.apply(null, args)
client.auth(auth, function (err, res) {
client.auth(auth, (err, res) => {
assert.strictEqual(null, err)
assert.strictEqual('OK', res.toString())
return done(err)
@@ -45,17 +45,17 @@ if (process.platform !== 'win32') {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient.apply(null, args)
var time = Date.now()
client.auth(auth, function (err, res) {
const time = Date.now()
client.auth(auth, (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual('retry worked', res)
var now = Date.now()
const now = Date.now()
// Hint: setTimeout sometimes triggers early and therefore the value can be like one or two ms to early
assert(now - time >= 98, 'Time should be above 100 ms (the reconnect time) and is ' + (now - time))
assert(now - time < 225, 'Time should be below 255 ms (the reconnect should only take a bit above 100 ms) and is ' + (now - time))
assert(now - time >= 98, `Time should be above 100 ms (the reconnect time) and is ${now - time}`)
assert(now - time < 225, `Time should be below 255 ms (the reconnect should only take a bit above 100 ms) and is ${now - time}`)
done()
})
var tmp = client.commandQueue.get(0).callback
const tmp = client.commandQueue.get(0).callback
client.commandQueue.get(0).callback = function (err) {
assert.strictEqual(err, null)
client.auth = function (pass, callback) {
@@ -70,13 +70,13 @@ if (process.platform !== 'win32') {
client = redis.createClient.apply(null, args)
client.once('error', function (err) {
client.once('error', (err) => {
assert.strictEqual(err.command, 'AUTH')
assert.ok(/ERR invalid password/.test(err.message))
return done()
})
client.auth(auth + 'bad')
client.auth(`${auth}bad`)
})
it('returns an error when auth is bad (empty string) with a callback', function (done) {
@@ -84,7 +84,7 @@ if (process.platform !== 'win32') {
client = redis.createClient.apply(null, args)
client.auth('', function (err) {
client.auth('', (err) => {
assert.strictEqual(err.command, 'AUTH')
assert.ok(/ERR invalid password/.test(err.message))
done()
@@ -95,13 +95,13 @@ if (process.platform !== 'win32') {
it('allows auth to be provided as part of redis url and do not fire commands before auth is done', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var end = helper.callFuncAfter(done, 2)
client = redis.createClient('redis://:' + auth + '@' + config.HOST[ip] + ':' + config.PORT)
client.on('ready', function () {
const end = helper.callFuncAfter(done, 2)
client = redis.createClient(`redis://:${auth}@${config.HOST[ip]}:${config.PORT}`)
client.on('ready', () => {
end()
})
// The info command may be used while loading but not if not yet authenticated
client.info(function (err) {
client.info((err) => {
assert.strictEqual(err, null)
end(err)
})
@@ -110,17 +110,17 @@ if (process.platform !== 'win32') {
it('allows auth and database to be provided as part of redis url query parameter', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient('redis://' + config.HOST[ip] + ':' + config.PORT + '?db=2&password=' + auth)
client = redis.createClient(`redis://${config.HOST[ip]}:${config.PORT}?db=2&password=${auth}`)
assert.strictEqual(client.options.db, '2')
assert.strictEqual(client.options.password, auth)
assert.strictEqual(client.authPass, auth)
client.on('ready', function () {
client.on('ready', () => {
// Set a key so the used database is returned in the info command
client.set('foo', 'bar')
client.get('foo')
assert.strictEqual(client.serverInfo.db2, undefined)
// Using the info command should update the serverInfo
client.info(function (err) {
client.info((err) => {
assert.strictEqual(err, null)
assert(typeof client.serverInfo.db2 === 'object')
})
@@ -132,7 +132,7 @@ if (process.platform !== 'win32') {
it('allows auth to be provided as config option for client', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
authPass: auth
})
client = redis.createClient.apply(null, args)
@@ -142,7 +142,7 @@ if (process.platform !== 'win32') {
it('allows auth and noReadyCheck to be provided as config option for client', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
password: auth,
noReadyCheck: true
})
@@ -153,7 +153,7 @@ if (process.platform !== 'win32') {
it('allows auth to be provided post-hoc with auth method', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip)
const args = config.configureClient(ip)
client = redis.createClient.apply(null, args)
client.auth(auth)
client.on('ready', done)
@@ -166,7 +166,7 @@ if (process.platform !== 'win32') {
client.auth(auth)
client.on('ready', function () {
if (this.timesConnected < 3) {
var interval = setInterval(function () {
let interval = setInterval(() => {
if (client.commandQueue.length !== 0) {
return
}
@@ -181,46 +181,19 @@ if (process.platform !== 'win32') {
done()
}
})
client.on('reconnecting', function (params) {
client.on('reconnecting', (params) => {
assert.strictEqual(params.error, null)
})
})
it('should return an error if the password is not correct and a callback has been provided', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient.apply(null, args)
var async = true
client.auth(undefined, function (err, res) {
assert.strictEqual(err.message, 'ERR invalid password')
assert.strictEqual(err.command, 'AUTH')
assert.strictEqual(res, undefined)
async = false
done()
})
assert(async)
})
it('should emit an error if the password is not correct and no callback has been provided', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient.apply(null, args)
client.on('error', function (err) {
assert.strictEqual(err.message, 'ERR invalid password')
assert.strictEqual(err.command, 'AUTH')
done()
})
client.auth(234567)
})
it('allows auth to be provided post-hoc with auth method again', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
authPass: auth
})
client = redis.createClient.apply(null, args)
client.on('ready', function () {
client.on('ready', () => {
client.auth(auth, helper.isString('OK', done))
})
})
@@ -228,12 +201,12 @@ if (process.platform !== 'win32') {
it('does not allow any commands to be processed if not authenticated using noReadyCheck true', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
noReadyCheck: true
})
client = redis.createClient.apply(null, args)
client.on('ready', function () {
client.set('foo', 'bar', function (err) {
client.on('ready', () => {
client.set('foo', 'bar', (err) => {
assert.strictEqual(err.message, 'NOAUTH Authentication required.')
assert.strictEqual(err.code, 'NOAUTH')
assert.strictEqual(err.command, 'SET')
@@ -245,7 +218,7 @@ if (process.platform !== 'win32') {
it('does not allow auth to be provided post-hoc with auth method if not authenticated before', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
client = redis.createClient.apply(null, args)
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'NOAUTH')
assert.strictEqual(err.message, 'Ready check failed: NOAUTH Authentication required.')
assert.strictEqual(err.command, 'INFO')
@@ -258,7 +231,7 @@ if (process.platform !== 'win32') {
client = redis.createClient({
password: 'wrongPassword'
})
client.once('error', function (err) {
client.once('error', (err) => {
assert.strictEqual(err.message, 'ERR invalid password')
done()
})
@@ -267,49 +240,49 @@ if (process.platform !== 'win32') {
it('pubsub working with auth', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
password: auth
})
client = redis.createClient.apply(null, args)
client.set('foo', 'bar')
client.subscribe('somechannel', 'another channel', function (err) {
client.subscribe('somechannel', 'another channel', (err) => {
assert.strictEqual(err, null)
client.once('ready', function () {
client.once('ready', () => {
assert.strictEqual(client.pubSubMode, 1)
client.get('foo', function (err) {
client.get('foo', (err) => {
assert(/ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message))
done()
})
})
})
client.once('ready', function () {
client.once('ready', () => {
// Coherent behavior with all other offline commands fires commands before emitting but does not wait till they return
assert.strictEqual(client.pubSubMode, 2)
client.ping(function () { // Make sure all commands were properly processed already
client.ping(() => { // Make sure all commands were properly processed already
client.stream.destroy()
})
})
})
it('individual commands work properly with batch', function (done) {
it('individual commands work properly with batch', (done) => {
// quit => might return an error instead of "OK" in the exec callback... (if not connected)
// auth => might return an error instead of "OK" in the exec callback... (if no password is required / still loading on Redis <= 2.4)
// This could be fixed by checking the return value of the callback in the exec callback and
// returning the manipulated [error, result] from the callback.
// There should be a better solution though
var args = config.configureClient('localhost', {
const args = config.configureClient('localhost', {
noReadyCheck: true
})
client = redis.createClient.apply(null, args)
assert.strictEqual(client.selectedDb, undefined)
var end = helper.callFuncAfter(done, 8)
client.on('monitor', function () {
const end = helper.callFuncAfter(done, 8)
client.on('monitor', () => {
end() // Should be called for each command after monitor
})
client.batch()
.auth(auth)
.select(5, function (err, res) {
.select(5, (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(client.selectedDb, 5)
assert.strictEqual(res, 'OK')
@@ -317,7 +290,7 @@ if (process.platform !== 'win32') {
})
.monitor()
.set('foo', 'bar', helper.isString('OK'))
.info('stats', function (err, res) {
.info('stats', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.indexOf('# Stats\r\n'), 0)
assert.strictEqual(client.serverInfo.sync_full, '0')
@@ -328,7 +301,7 @@ if (process.platform !== 'win32') {
.subscribe('/foo', helper.isDeepEqual([2, ['/foo']]))
.psubscribe('*')
.quit(helper.isString('OK'))
.exec(function (err, res) {
.exec((err, res) => {
assert.strictEqual(err, null)
res[4] = res[4].substr(0, 9)
assert.deepStrictEqual(
@@ -341,9 +314,9 @@ if (process.platform !== 'win32') {
})
})
after(function (done) {
after((done) => {
if (helper.redisProcess().spawnFailed()) return done()
helper.stopRedis(function () {
helper.stopRedis(() => {
helper.startRedis('./conf/redis.conf', done)
})
})

155
test/batch.spec.js
View File

@@ -1,73 +1,73 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
describe('The \'batch\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
describe('when not connected', function () {
var client
describe('The \'batch\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('connect', function () {
client.once('connect', () => {
client.quit()
})
client.on('end', done)
})
it('returns an empty array for missing commands', function (done) {
var batch = client.batch()
batch.exec(function (err, res) {
it('returns an empty array for missing commands', (done) => {
const batch = client.batch()
batch.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
done()
})
})
it('returns an error for batch with commands', function (done) {
var batch = client.batch()
it('returns an error for batch with commands', (done) => {
const batch = client.batch()
batch.set('foo', 'bar')
batch.exec(function (err, res) {
batch.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res[0].code, 'NR_CLOSED')
done()
})
})
it('returns an empty array for missing commands if promisified', function () {
return client.batch().execAsync().then(function (res) {
it('returns an empty array for missing commands if promisified', () => {
return client.batch().execAsync().then((res) => {
assert.strictEqual(res.length, 0)
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.flushdb(function (err) {
client.once('ready', () => {
client.flushdb((err) => {
return done(err)
})
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('returns an empty array and keep the execution order in tact', function (done) {
var called = false
client.set('foo', 'bar', function () {
it('returns an empty array and keep the execution order in tact', (done) => {
let called = false
client.set('foo', 'bar', () => {
called = true
})
var batch = client.batch()
batch.exec(function (err, res) {
const batch = client.batch()
batch.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
assert(called)
@@ -75,47 +75,45 @@ describe('The \'batch\' method', function () {
})
})
it('runs normal calls in-between batch', function (done) {
var batch = client.batch()
it('runs normal calls in-between batch', (done) => {
const batch = client.batch()
batch.set('m1', '123')
client.set('m2', '456', done)
})
it('returns an empty array if promisified', function () {
return client.batch().execAsync().then(function (res) {
it('returns an empty array if promisified', () => {
return client.batch().execAsync().then((res) => {
assert.strictEqual(res.length, 0)
})
})
it('returns an empty result array', function (done) {
var batch = client.batch()
var async = true
var notBuffering = batch.exec(function (err, res) {
it('returns an empty result array', (done) => {
const batch = client.batch()
let async = true
batch.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
async = false
done()
})
assert(async)
assert.strictEqual(notBuffering, true)
})
it('fail individually when one command fails using chaining notation', function (done) {
var batch1, batch2
batch1 = client.batch()
it('fail individually when one command fails using chaining notation', (done) => {
const batch1 = client.batch()
batch1.mset('batchfoo', '10', 'batchbar', '20', helper.isString('OK'))
// Provoke an error at queue time
batch1.set('foo2', helper.isError())
batch1.incr('batchfoo')
batch1.incr('batchbar')
batch1.exec(function () {
batch1.exec(() => {
// Confirm that the previous command, while containing an error, still worked.
batch2 = client.batch()
const batch2 = client.batch()
batch2.get('foo2', helper.isNull())
batch2.incr('batchbar', helper.isNumber(22))
batch2.incr('batchfoo', helper.isNumber(12))
batch2.exec(function (err, replies) {
batch2.exec((err, replies) => {
assert.strictEqual(err, null)
assert.strictEqual(null, replies[0])
assert.strictEqual(22, replies[1])
@@ -125,19 +123,18 @@ describe('The \'batch\' method', function () {
})
})
it('fail individually when one command fails and emit the error if no callback has been provided', function (done) {
var batch1
client.on('error', function (err) {
it('fail individually when one command fails and emit the error if no callback has been provided', (done) => {
client.on('error', (err) => {
done(err)
})
batch1 = client.batch()
const batch1 = client.batch()
batch1.mset('batchfoo', '10', 'batchbar', '20', helper.isString('OK'))
// Provoke an error at queue time
batch1.set('foo2')
batch1.incr('batchfoo')
batch1.incr('batchbar')
batch1.exec(function (err, res) {
batch1.exec((err, res) => {
// TODO: This should actually return an error!
assert.strictEqual(err, null)
assert.strictEqual(res[1].command, 'SET')
@@ -146,14 +143,14 @@ describe('The \'batch\' method', function () {
})
})
it('fail individually when one command in an array of commands fails', function (done) {
it('fail individually when one command in an array of commands fails', (done) => {
// test nested batch-bulk replies
client.batch([
['mget', 'batchfoo', 'batchbar', helper.isDeepEqual([null, null])],
['set', 'foo2', helper.isError()],
['incr', 'batchfoo'],
['incr', 'batchbar']
]).exec(function (err, replies) {
]).exec((err, replies) => {
// TODO: This should actually return an error!
assert.strictEqual(err, null)
assert.strictEqual(2, replies[0].length)
@@ -166,7 +163,7 @@ describe('The \'batch\' method', function () {
})
})
it('handles multiple operations being applied to a set', function (done) {
it('handles multiple operations being applied to a set', (done) => {
client.sadd('some set', 'mem 1')
client.sadd(['some set', 'mem 2'])
client.sadd('some set', 'mem 3')
@@ -174,7 +171,7 @@ describe('The \'batch\' method', function () {
// make sure empty mb reply works
client.del('some missing set')
client.smembers('some missing set', function (err, reply) {
client.smembers('some missing set', (err, reply) => {
assert.strictEqual(err, null)
// make sure empty mb reply works
assert.strictEqual(0, reply.length)
@@ -187,7 +184,7 @@ describe('The \'batch\' method', function () {
['smembers', 'some set', undefined] // The explicit undefined is handled as a callback that is undefined
])
.scard('some set')
.exec(function (err, replies) {
.exec((err, replies) => {
assert.strictEqual(err, null)
assert.strictEqual(4, replies[0].length)
assert.strictEqual(0, replies[2].length)
@@ -195,12 +192,12 @@ describe('The \'batch\' method', function () {
})
})
it('allows multiple operations to be performed using constructor with all kinds of syntax', function (done) {
var now = Date.now()
var arr = ['batchhmset', 'batchbar', 'batchbaz']
var arr2 = ['some manner of key', 'otherTypes']
var arr3 = [5768, 'batchbarx', 'batchfoox']
var arr4 = ['mset', [578, 'batchbar'], helper.isString('OK')]
it('allows multiple operations to be performed using constructor with all kinds of syntax', (done) => {
const now = Date.now()
const arr = ['batchhmset', 'batchbar', 'batchbaz']
const arr2 = ['some manner of key', 'otherTypes']
const arr3 = [5768, 'batchbarx', 'batchfoox']
const arr4 = ['mset', [578, 'batchbar'], helper.isString('OK')]
client.batch([
arr4,
[['mset', 'batchfoo2', 'batchbar2', 'batchfoo3', 'batchbar3'], helper.isString('OK')],
@@ -214,15 +211,15 @@ describe('The \'batch\' method', function () {
['hmset', 'batchhmset', ['batchbar', 'batchbaz'], helper.isString('OK')]
])
.hmget(now, 123456789, 'otherTypes')
.hmget('key2', arr2, function noop () {})
.hmget('key2', arr2, () => {})
.hmget(['batchhmset2', 'some manner of key', 'batchbar3'])
.mget('batchfoo2', ['batchfoo3', 'batchfoo'], function (err, res) {
.mget('batchfoo2', ['batchfoo3', 'batchfoo'], (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res[0], 'batchbar2')
assert.strictEqual(res[1], 'batchbar3')
assert.strictEqual(res[2], null)
})
.exec(function (err, replies) {
.exec((err, replies) => {
assert.strictEqual(arr.length, 3)
assert.strictEqual(arr2.length, 2)
assert.strictEqual(arr3.length, 3)
@@ -239,7 +236,7 @@ describe('The \'batch\' method', function () {
})
})
it('converts a non string key to a string', function (done) {
it('converts a non string key to a string', (done) => {
// TODO: Converting the key might change soon again.
client.batch().hmset(true, {
test: 123,
@@ -247,21 +244,19 @@ describe('The \'batch\' method', function () {
}).exec(done)
})
it('runs a batch without any further commands', function (done) {
var buffering = client.batch().exec(function (err, res) {
it('runs a batch without any further commands', (done) => {
client.batch().exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
done()
})
assert(typeof buffering === 'boolean')
})
it('runs a batch without any further commands and without callback', function () {
var buffering = client.batch().exec()
assert.strictEqual(buffering, true)
it('runs a batch without any further commands and without callback', () => {
client.batch().exec()
})
it('allows multiple operations to be performed using a chaining API', function (done) {
it('allows multiple operations to be performed using a chaining API', (done) => {
client.batch()
.mset('some', '10', 'keys', '20')
.incr('some')
@@ -270,7 +265,7 @@ describe('The \'batch\' method', function () {
.exec(helper.isDeepEqual(['OK', 11, 21, ['11', '21']], done))
})
it('allows multiple commands to work the same as normal to be performed using a chaining API', function (done) {
it('allows multiple commands to work the same as normal to be performed using a chaining API', (done) => {
client.batch()
.mset(['some', '10', 'keys', '20'])
.incr('some', helper.isNumber(11))
@@ -279,25 +274,25 @@ describe('The \'batch\' method', function () {
.exec(helper.isDeepEqual(['OK', 11, 21, ['11', '21']], done))
})
it('allows multiple commands to work the same as normal to be performed using a chaining API promisified', function () {
it('allows multiple commands to work the same as normal to be performed using a chaining API promisified', () => {
return client.batch()
.mset(['some', '10', 'keys', '20'])
.incr('some', helper.isNumber(11))
.incr(['keys'], helper.isNumber(21))
.mget('some', 'keys')
.execAsync()
.then(function (res) {
.then((res) => {
helper.isDeepEqual(['OK', 11, 21, ['11', '21']])(null, res)
})
})
it('allows an array to be provided indicating multiple operations to perform', function (done) {
it('allows an array to be provided indicating multiple operations to perform', (done) => {
// test nested batch-bulk replies with nulls.
client.batch([
['mget', ['batchfoo', 'some', 'random value', 'keys']],
['incr', 'batchfoo']
])
.exec(function (err, replies) {
.exec((err, replies) => {
assert.strictEqual(err, null)
assert.strictEqual(replies.length, 2)
assert.strictEqual(replies[0].length, 4)
@@ -305,7 +300,7 @@ describe('The \'batch\' method', function () {
})
})
it('allows multiple operations to be performed on a hash', function (done) {
it('allows multiple operations to be performed on a hash', (done) => {
client.batch()
.hmset('batchhash', 'a', 'foo', 'b', 1)
.hmset('batchhash', {
@@ -316,8 +311,8 @@ describe('The \'batch\' method', function () {
.exec(done)
})
it('should work without any callback or arguments', function (done) {
var batch = client.batch()
it('should work without any callback or arguments', (done) => {
const batch = client.batch()
batch.set('baz', 'binary')
batch.set('foo', 'bar')
batch.ping()

46
test/commands/blpop.spec.js
View File

@@ -1,29 +1,29 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var intercept = require('intercept-stdout')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const intercept = require('intercept-stdout')
describe('The \'blpop\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var bclient
describe('The \'blpop\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
let bclient
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('pops value immediately if list contains values', function (done) {
it('pops value immediately if list contains values', (done) => {
bclient = redis.createClient.apply(null, args)
redis.debugMode = true
var text = ''
var unhookIntercept = intercept(function (data) {
let text = ''
const unhookIntercept = intercept((data) => {
text += data
return ''
})
@@ -31,26 +31,26 @@ describe('The \'blpop\' method', function () {
unhookIntercept()
assert(/^Send 127\.0\.0\.1:6379 id [0-9]+: \*3\r\n\$5\r\nrpush\r\n\$13\r\nblocking list\r\n\$13\r\ninitial value\r\n\n$/.test(text))
redis.debugMode = false
bclient.blpop('blocking list', 0, function (err, value) {
bclient.blpop('blocking list', 0, (err, value) => {
assert.strictEqual(value[0], 'blocking list')
assert.strictEqual(value[1], 'initial value')
return done(err)
})
})
it('pops value immediately if list contains values using array notation', function (done) {
it('pops value immediately if list contains values using array notation', (done) => {
bclient = redis.createClient.apply(null, args)
client.rpush(['blocking list', 'initial value'], helper.isNumber(1))
bclient.blpop(['blocking list', 0], function (err, value) {
bclient.blpop(['blocking list', 0], (err, value) => {
assert.strictEqual(value[0], 'blocking list')
assert.strictEqual(value[1], 'initial value')
return done(err)
})
})
it('waits for value if list is not yet populated', function (done) {
it('waits for value if list is not yet populated', (done) => {
bclient = redis.createClient.apply(null, args)
bclient.blpop('blocking list 2', 5, function (err, value) {
bclient.blpop('blocking list 2', 5, (err, value) => {
assert.strictEqual(value[0], 'blocking list 2')
assert.strictEqual(value[1], 'initial value')
return done(err)
@@ -58,15 +58,15 @@ describe('The \'blpop\' method', function () {
client.rpush('blocking list 2', 'initial value', helper.isNumber(1))
})
it('times out after specified time', function (done) {
it('times out after specified time', (done) => {
bclient = redis.createClient.apply(null, args)
bclient.blpop('blocking list', 1, function (err, res) {
bclient.blpop('blocking list', 1, (err, res) => {
assert.strictEqual(res, null)
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
bclient.end(true)
})

66
test/commands/client.spec.js
View File

@@ -1,51 +1,51 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'client\' method', function () {
helper.allTests(function (ip, args) {
var pattern = /addr=/
describe('The \'client\' method', () => {
helper.allTests((ip, args) => {
const pattern = /addr=/
describe('using ' + ip, function () {
var client
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('list', function () {
it('lists connected clients', function (done) {
describe('list', () => {
it('lists connected clients', (done) => {
client.client('LIST', helper.match(pattern, done))
})
it('lists connected clients when invoked with multi\'s chaining syntax', function (done) {
it('lists connected clients when invoked with multi\'s chaining syntax', (done) => {
client.multi().client('list', helper.isType.string()).exec(helper.match(pattern, done))
})
it('lists connected clients when invoked with array syntax on client', function (done) {
it('lists connected clients when invoked with array syntax on client', (done) => {
client.multi().client(['list']).exec(helper.match(pattern, done))
})
it('lists connected clients when invoked with multi\'s array syntax', function (done) {
it('lists connected clients when invoked with multi\'s array syntax', (done) => {
client.multi([
['client', 'list']
]).exec(helper.match(pattern, done))
})
})
describe('reply', function () {
describe('as normal command', function () {
describe('reply', () => {
describe('as normal command', () => {
it('on', function (done) {
helper.serverVersionAtLeast.call(this, client, [3, 2, 0])
assert.strictEqual(client.reply, 'ON')
@@ -72,15 +72,15 @@ describe('The \'client\' method', function () {
})
})
describe('in a batch context', function () {
describe('in a batch context', () => {
it('on', function (done) {
helper.serverVersionAtLeast.call(this, client, [3, 2, 0])
var batch = client.batch()
const batch = client.batch()
assert.strictEqual(client.reply, 'ON')
batch.client('reply', 'on', helper.isString('OK'))
assert.strictEqual(client.reply, 'ON')
batch.set('foo', 'bar')
batch.exec(function (err, res) {
batch.exec((err, res) => {
assert.deepEqual(res, ['OK', 'OK'])
done(err)
})
@@ -88,12 +88,12 @@ describe('The \'client\' method', function () {
it('off', function (done) {
helper.serverVersionAtLeast.call(this, client, [3, 2, 0])
var batch = client.batch()
const batch = client.batch()
assert.strictEqual(client.reply, 'ON')
batch.set('hello', 'world')
batch.client(Buffer.from('REPLY'), Buffer.from('OFF'), helper.isUndefined())
batch.set('foo', 'bar', helper.isUndefined())
batch.exec(function (err, res) {
batch.exec((err, res) => {
assert.strictEqual(client.reply, 'OFF')
assert.deepEqual(res, ['OK', undefined, undefined])
done(err)
@@ -108,7 +108,7 @@ describe('The \'client\' method', function () {
.client('REPLY', 'SKIP', helper.isUndefined())
.set('foo', 'bar', helper.isUndefined())
.get('foo')
.exec(function (err, res) {
.exec((err, res) => {
assert.strictEqual(client.reply, 'ON')
assert.deepEqual(res, ['OK', undefined, undefined, 'bar'])
done(err)
@@ -117,24 +117,24 @@ describe('The \'client\' method', function () {
})
})
describe('setname / getname', function () {
var client2
describe('setname / getname', () => {
let client2
beforeEach(function (done) {
beforeEach((done) => {
client2 = redis.createClient.apply(null, args)
client2.once('ready', function () {
client2.once('ready', () => {
done()
})
})
afterEach(function () {
afterEach(() => {
client2.end(true)
})
it('sets the name', function (done) {
it('sets the name', (done) => {
// The querys are auto pipelined and the response is a response to all querys of one client
// per chunk. So the execution order is only guaranteed on each client
var end = helper.callFuncAfter(done, 2)
const end = helper.callFuncAfter(done, 2)
client.client('setname', 'RUTH')
client2.client('setname', ['RENEE'], helper.isString('OK'))

62
test/commands/dbsize.spec.js
View File

@@ -1,59 +1,59 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'dbsize\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, value
describe('The \'dbsize\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, value
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
value = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.dbsize([], function (err, res) {
it('reports an error', (done) => {
client.dbsize([], (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.flushdb(function (err, res) {
client.once('ready', () => {
client.flushdb((err, res) => {
helper.isString('OK')(err, res)
done()
})
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('returns a zero db size', function (done) {
client.dbsize([], function (err, res) {
it('returns a zero db size', (done) => {
client.dbsize([], (err, res) => {
helper.isNotError()(err, res)
helper.isType.number()(err, res)
assert.strictEqual(res, 0, 'Initial db size should be 0')
@@ -61,25 +61,25 @@ describe('The \'dbsize\' method', function () {
})
})
describe('when more data is added to Redis', function () {
var oldSize
describe('when more data is added to Redis', () => {
let oldSize
beforeEach(function (done) {
client.dbsize(function (err, res) {
beforeEach((done) => {
client.dbsize((err, res) => {
helper.isType.number()(err, res)
assert.strictEqual(res, 0, 'Initial db size should be 0')
oldSize = res
client.set(key, value, function (err, res) {
client.set(key, value, (err, res) => {
helper.isNotError()(err, res)
done()
})
})
})
it('returns a larger db size', function (done) {
client.dbsize([], function (err, res) {
it('returns a larger db size', (done) => {
client.dbsize([], (err, res) => {
helper.isNotError()(err, res)
helper.isType.positiveNumber()(err, res)
assert.strictEqual(true, (oldSize < res), 'Adding data should increase db size.')

30
test/commands/del.spec.js
View File

@@ -1,53 +1,53 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'del\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'del\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('allows a single key to be deleted', function (done) {
it('allows a single key to be deleted', (done) => {
client.set('foo', 'bar')
client.del('foo', helper.isNumber(1))
client.get('foo', helper.isNull(done))
})
it('allows del to be called on a key that does not exist', function (done) {
it('allows del to be called on a key that does not exist', (done) => {
client.del('foo', helper.isNumber(0, done))
})
it('allows multiple keys to be deleted', function (done) {
it('allows multiple keys to be deleted', (done) => {
client.mset('foo', 'bar', 'apple', 'banana')
client.del('foo', 'apple', helper.isNumber(2))
client.get('foo', helper.isNull())
client.get('apple', helper.isNull(done))
})
it('allows multiple keys to be deleted with the array syntax', function (done) {
it('allows multiple keys to be deleted with the array syntax', (done) => {
client.mset('foo', 'bar', 'apple', 'banana')
client.del(['foo', 'apple'], helper.isNumber(2))
client.get('foo', helper.isNull())
client.get('apple', helper.isNull(done))
})
it('allows multiple keys to be deleted with the array syntax and no callback', function (done) {
it('allows multiple keys to be deleted with the array syntax and no callback', (done) => {
client.mset('foo', 'bar', 'apple', 'banana')
client.del(['foo', 'apple'])
client.get('foo', helper.isNull())
client.get('apple', helper.isNull(done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

102
test/commands/eval.spec.js
View File

@@ -1,58 +1,58 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var crypto = require('crypto')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const crypto = require('crypto')
const helper = require('../helper')
const redis = config.redis
describe('The \'eval\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var source = 'return redis.call(\'set\', \'sha\', \'test\')'
describe('The \'eval\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
const source = 'return redis.call(\'set\', \'sha\', \'test\')'
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('converts a float to an integer when evaluated', function (done) {
it('converts a float to an integer when evaluated', (done) => {
client.eval('return 100.5', 0, helper.isNumber(100, done))
})
it('returns a string', function (done) {
it('returns a string', (done) => {
client.eval('return \'hello world\'', 0, helper.isString('hello world', done))
})
it('converts boolean true to integer 1', function (done) {
it('converts boolean true to integer 1', (done) => {
client.eval('return true', 0, helper.isNumber(1, done))
})
it('converts boolean false to null', function (done) {
it('converts boolean false to null', (done) => {
client.eval('return false', 0, helper.isNull(done))
})
it('converts lua status code to string representation', function (done) {
it('converts lua status code to string representation', (done) => {
client.eval('return {ok=\'fine\'}', 0, helper.isString('fine', done))
})
it('converts lua error to an error response', function (done) {
client.eval('return {err=\'this is an error\'}', 0, function (err) {
it('converts lua error to an error response', (done) => {
client.eval('return {err=\'this is an error\'}', 0, (err) => {
assert(err.code === undefined)
helper.isError()(err)
done()
})
})
it('represents a lua table appropritely', function (done) {
client.eval('return {1,2,3,\'ciao\',{1,2}}', 0, function (err, res) {
it('represents a lua table appropritely', (done) => {
client.eval('return {1,2,3,\'ciao\',{1,2}}', 0, (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(5, res.length)
assert.strictEqual(1, res[0])
@@ -66,47 +66,47 @@ describe('The \'eval\' method', function () {
})
})
it('populates keys and argv correctly', function (done) {
it('populates keys and argv correctly', (done) => {
client.eval('return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}', 2, 'a', 'b', 'c', 'd', helper.isDeepEqual(['a', 'b', 'c', 'd'], done))
})
it('allows arguments to be provided in array rather than as multiple parameters', function (done) {
it('allows arguments to be provided in array rather than as multiple parameters', (done) => {
client.eval(['return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}', 2, 'a', 'b', 'c', 'd'], helper.isDeepEqual(['a', 'b', 'c', 'd'], done))
})
it('allows a script to be executed that accesses the redis API without callback', function (done) {
it('allows a script to be executed that accesses the redis API without callback', (done) => {
client.eval(source, 0)
client.get('sha', helper.isString('test', done))
})
describe('evalsha', function () {
var sha = crypto.createHash('sha1').update(source).digest('hex')
describe('evalsha', () => {
const sha = crypto.createHash('sha1').update(source).digest('hex')
it('allows a script to be executed that accesses the redis API', function (done) {
it('allows a script to be executed that accesses the redis API', (done) => {
client.eval(source, 0, helper.isString('OK'))
client.get('sha', helper.isString('test', done))
})
it('can execute a script if the SHA exists', function (done) {
it('can execute a script if the SHA exists', (done) => {
client.evalsha(sha, 0, helper.isString('OK'))
client.get('sha', helper.isString('test', done))
})
it('returns an error if SHA does not exist', function (done) {
it('returns an error if SHA does not exist', (done) => {
client.evalsha('ffffffffffffffffffffffffffffffffffffffff', 0, helper.isError(done))
})
it('emit an error if SHA does not exist without any callback', function (done) {
it('emit an error if SHA does not exist without any callback', (done) => {
client.evalsha('ffffffffffffffffffffffffffffffffffffffff', 0)
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'NOSCRIPT')
assert(/NOSCRIPT No matching script. Please use EVAL./.test(err.message))
done()
})
})
it('emits an error if SHA does not exist and no callback has been provided', function (done) {
client.on('error', function (err) {
it('emits an error if SHA does not exist and no callback has been provided', (done) => {
client.on('error', (err) => {
assert.strictEqual(err.message, 'NOSCRIPT No matching script. Please use EVAL.')
done()
})
@@ -114,10 +114,10 @@ describe('The \'eval\' method', function () {
})
})
it('allows a key to be incremented, and performs appropriate conversion from LUA type', function (done) {
client.set('incr key', 0, function (err, reply) {
it('allows a key to be incremented, and performs appropriate conversion from LUA type', (done) => {
client.set('incr key', 0, (err, reply) => {
if (err) return done(err)
client.eval('local foo = redis.call(\'incr\',\'incr key\')\nreturn {type(foo),foo}', 0, function (err, res) {
client.eval('local foo = redis.call(\'incr\',\'incr key\')\nreturn {type(foo),foo}', 0, (err, res) => {
assert.strictEqual(2, res.length)
assert.strictEqual('number', res[0])
assert.strictEqual(1, res[1])
@@ -126,10 +126,10 @@ describe('The \'eval\' method', function () {
})
})
it('allows a bulk operation to be performed, and performs appropriate conversion from LUA type', function (done) {
client.set('bulk reply key', 'bulk reply value', function (err, res) {
it('allows a bulk operation to be performed, and performs appropriate conversion from LUA type', (done) => {
client.set('bulk reply key', 'bulk reply value', (err, res) => {
assert.strictEqual(err, null)
client.eval('local foo = redis.call(\'get\',\'bulk reply key\'); return {type(foo),foo}', 0, function (err, res) {
client.eval('local foo = redis.call(\'get\',\'bulk reply key\'); return {type(foo),foo}', 0, (err, res) => {
assert.strictEqual(2, res.length)
assert.strictEqual('string', res[0])
assert.strictEqual('bulk reply value', res[1])
@@ -138,15 +138,15 @@ describe('The \'eval\' method', function () {
})
})
it('allows a multi mulk operation to be performed, with the appropriate type conversion', function (done) {
it('allows a multi mulk operation to be performed, with the appropriate type conversion', (done) => {
client.multi()
.del('mylist')
.rpush('mylist', 'a')
.rpush('mylist', 'b')
.rpush('mylist', 'c')
.exec(function (err, replies) {
.exec((err, replies) => {
if (err) return done(err)
client.eval('local foo = redis.call(\'lrange\',\'mylist\',0,-1); return {type(foo),foo[1],foo[2],foo[3],# foo}', 0, function (err, res) {
client.eval('local foo = redis.call(\'lrange\',\'mylist\',0,-1); return {type(foo),foo[1],foo[2],foo[3],# foo}', 0, (err, res) => {
assert.strictEqual(5, res.length)
assert.strictEqual('table', res[0])
assert.strictEqual('a', res[1])
@@ -158,8 +158,8 @@ describe('The \'eval\' method', function () {
})
})
it('returns an appropriate representation of Lua status reply', function (done) {
client.eval('local foo = redis.call(\'set\',\'mykey\',\'myval\'); return {type(foo),foo[\'ok\']}', 0, function (err, res) {
it('returns an appropriate representation of Lua status reply', (done) => {
client.eval('local foo = redis.call(\'set\',\'mykey\',\'myval\'); return {type(foo),foo[\'ok\']}', 0, (err, res) => {
assert.strictEqual(2, res.length)
assert.strictEqual('table', res[0])
assert.strictEqual('OK', res[1])
@@ -167,10 +167,10 @@ describe('The \'eval\' method', function () {
})
})
it('returns an appropriate representation of a Lua error reply', function (done) {
client.set('error reply key', 'error reply value', function (err, res) {
it('returns an appropriate representation of a Lua error reply', (done) => {
client.set('error reply key', 'error reply value', (err, res) => {
if (err) return done(err)
client.eval('local foo = redis.pcall(\'incr\',\'error reply key\'); return {type(foo),foo[\'err\']}', 0, function (err, res) {
client.eval('local foo = redis.pcall(\'incr\',\'error reply key\'); return {type(foo),foo[\'err\']}', 0, (err, res) => {
assert.strictEqual(2, res.length)
assert.strictEqual('table', res[0])
assert.strictEqual('ERR value is not an integer or out of range', res[1])
@@ -179,10 +179,10 @@ describe('The \'eval\' method', function () {
})
})
it('returns an appropriate representation of a Lua nil reply', function (done) {
client.del('nil reply key', function (err, res) {
it('returns an appropriate representation of a Lua nil reply', (done) => {
client.del('nil reply key', (err, res) => {
if (err) return done(err)
client.eval('local foo = redis.call(\'get\',\'nil reply key\'); return {type(foo),foo == false}', 0, function (err, res) {
client.eval('local foo = redis.call(\'get\',\'nil reply key\'); return {type(foo),foo == false}', 0, (err, res) => {
if (err) throw err
assert.strictEqual(2, res.length)
assert.strictEqual('boolean', res[0])

26
test/commands/exists.spec.js
View File

@@ -1,36 +1,36 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'exists\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'exists\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns 1 if the key exists', function (done) {
it('returns 1 if the key exists', (done) => {
client.set('foo', 'bar')
client.exists('foo', helper.isNumber(1, done))
})
it('returns 1 if the key exists with array syntax', function (done) {
it('returns 1 if the key exists with array syntax', (done) => {
client.set('foo', 'bar')
client.exists(['foo'], helper.isNumber(1, done))
})
it('returns 0 if the key does not exist', function (done) {
it('returns 0 if the key does not exist', (done) => {
client.exists('bar', helper.isNumber(0, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

28
test/commands/expire.spec.js
View File

@@ -1,38 +1,38 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'expire\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'expire\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('expires key after timeout', function (done) {
it('expires key after timeout', (done) => {
client.set(['expiry key', 'bar'], helper.isString('OK'))
client.expire('expiry key', '1', helper.isNumber(1))
setTimeout(function () {
setTimeout(() => {
client.exists(['expiry key'], helper.isNumber(0, done))
}, 1050)
})
it('expires key after timeout with array syntax', function (done) {
it('expires key after timeout with array syntax', (done) => {
client.set(['expiry key', 'bar'], helper.isString('OK'))
client.expire(['expiry key', '1'], helper.isNumber(1))
setTimeout(function () {
setTimeout(() => {
client.exists(['expiry key'], helper.isNumber(0, done))
}, 1050)
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

62
test/commands/flushdb.spec.js
View File

@@ -1,69 +1,69 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'flushdb\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, key2
describe('The \'flushdb\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, key2
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
key2 = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.flushdb(function (err, res) {
it('reports an error', (done) => {
client.flushdb((err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('when there is data in Redis', function () {
beforeEach(function (done) {
describe('when there is data in Redis', () => {
beforeEach((done) => {
client.mset(key, uuid.v4(), key2, uuid.v4(), helper.isNotError())
client.dbsize([], function (err, res) {
client.dbsize([], (err, res) => {
helper.isType.positiveNumber()(err, res)
assert.strictEqual(res, 2, 'Two keys should have been inserted')
done()
})
})
it('deletes all the keys', function (done) {
client.flushdb(function (err, res) {
it('deletes all the keys', (done) => {
client.flushdb((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'OK')
client.mget(key, key2, function (err, res) {
client.mget(key, key2, (err, res) => {
assert.strictEqual(null, err, 'Unexpected error returned')
assert.strictEqual(true, Array.isArray(res), 'Results object should be an array.')
assert.strictEqual(2, res.length, 'Results array should have length 2.')
@@ -74,16 +74,16 @@ describe('The \'flushdb\' method', function () {
})
})
it('results in a db size of zero', function (done) {
client.flushdb(function (err, res) {
it('results in a db size of zero', (done) => {
client.flushdb((err, res) => {
assert.strictEqual(err, null)
client.dbsize([], helper.isNumber(0, done))
})
})
it('results in a db size of zero without a callback', function (done) {
it('results in a db size of zero without a callback', (done) => {
client.flushdb()
setTimeout(function () {
setTimeout(() => {
client.dbsize(helper.isNumber(0, done))
}, 25)
})

22
test/commands/geoadd.spec.js
View File

@@ -1,31 +1,31 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'geoadd\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'geoadd\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns 1 if the key exists', function (done) {
helper.serverVersionAtLeast.call(this, client, [3, 2, 0])
client.geoadd('mycity:21:0:location', '13.361389', '38.115556', 'COR', function (err, res) {
client.geoadd('mycity:21:0:location', '13.361389', '38.115556', 'COR', (err, res) => {
console.log(err, res)
// geoadd is still in the unstable branch. As soon as it reaches the stable one, activate this test
done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

66
test/commands/get.spec.js
View File

@@ -1,87 +1,87 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'get\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, value
describe('The \'get\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, value
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
value = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.get(key, function (err, res) {
it('reports an error', (done) => {
client.get(key, (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
it('reports an error promisified', function () {
return client.getAsync(key).then(assert, function (err) {
it('reports an error promisified', () => {
return client.getAsync(key).then(assert, (err) => {
assert(err.message.match(/The connection is already closed/))
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('when the key exists in Redis', function () {
beforeEach(function (done) {
client.set(key, value, function (err, res) {
describe('when the key exists in Redis', () => {
beforeEach((done) => {
client.set(key, value, (err, res) => {
helper.isNotError()(err, res)
done()
})
})
it('gets the value correctly', function (done) {
client.get(key, function (err, res) {
it('gets the value correctly', (done) => {
client.get(key, (err, res) => {
helper.isString(value)(err, res)
done(err)
})
})
it('should not throw on a get without callback (even if it\'s not useful)', function (done) {
it('should not throw on a get without callback (even if it\'s not useful)', (done) => {
client.get(key)
client.on('error', function (err) {
client.on('error', (err) => {
throw err
})
setTimeout(done, 25)
})
})
describe('when the key does not exist in Redis', function () {
it('gets a null value', function (done) {
client.get(key, function (err, res) {
describe('when the key does not exist in Redis', () => {
it('gets a null value', (done) => {
client.get(key, (err, res) => {
helper.isNull()(err, res)
done(err)
})

72
test/commands/getset.spec.js
View File

@@ -1,87 +1,87 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'getset\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, value, value2
describe('The \'getset\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, value, value2
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
value = uuid.v4()
value2 = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.get(key, function (err, res) {
it('reports an error', (done) => {
client.get(key, (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('when the key exists in Redis', function () {
beforeEach(function (done) {
client.set(key, value, function (err, res) {
describe('when the key exists in Redis', () => {
beforeEach((done) => {
client.set(key, value, (err, res) => {
helper.isNotError()(err, res)
done()
})
})
it('gets the value correctly', function (done) {
client.getset(key, value2, function (err, res) {
it('gets the value correctly', (done) => {
client.getset(key, value2, (err, res) => {
helper.isString(value)(err, res)
client.get(key, function (err, res) {
client.get(key, (err, res) => {
helper.isString(value2)(err, res)
done(err)
})
})
})
it('gets the value correctly with array syntax', function (done) {
client.getset([key, value2], function (err, res) {
it('gets the value correctly with array syntax', (done) => {
client.getset([key, value2], (err, res) => {
helper.isString(value)(err, res)
client.get(key, function (err, res) {
client.get(key, (err, res) => {
helper.isString(value2)(err, res)
done(err)
})
})
})
it('gets the value correctly with array syntax style 2', function (done) {
client.getset(key, [value2], function (err, res) {
it('gets the value correctly with array syntax style 2', (done) => {
client.getset(key, [value2], (err, res) => {
helper.isString(value)(err, res)
client.get(key, function (err, res) {
client.get(key, (err, res) => {
helper.isString(value2)(err, res)
done(err)
})
@@ -89,9 +89,9 @@ describe('The \'getset\' method', function () {
})
})
describe('when the key does not exist in Redis', function () {
it('gets a null value', function (done) {
client.getset(key, value, function (err, res) {
describe('when the key does not exist in Redis', () => {
it('gets a null value', (done) => {
client.getset(key, value, (err, res) => {
helper.isNull()(err, res)
done(err)
})

52
test/commands/hgetall.spec.js
View File

@@ -1,27 +1,27 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hgetall\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'hgetall\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
describe('regular client', function () {
beforeEach(function (done) {
describe('regular client', () => {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('handles simple keys and values', function (done) {
it('handles simple keys and values', (done) => {
client.hmset(['hosts', 'hasOwnProperty', '1', 'another', '23', 'home', '1234'], helper.isString('OK'))
client.hgetall(['hosts'], function (err, obj) {
client.hgetall(['hosts'], (err, obj) => {
assert.strictEqual(3, Object.keys(obj).length)
assert.strictEqual('1', obj.hasOwnProperty.toString())
assert.strictEqual('23', obj.another.toString())
@@ -30,39 +30,39 @@ describe('The \'hgetall\' method', function () {
})
})
it('handles fetching keys set using an object', function (done) {
it('handles fetching keys set using an object', (done) => {
client.batch().hmset('msgTest', { message: 'hello' }, undefined).exec()
client.hgetall('msgTest', function (err, obj) {
client.hgetall('msgTest', (err, obj) => {
assert.strictEqual(1, Object.keys(obj).length)
assert.strictEqual(obj.message, 'hello')
done(err)
})
})
it('handles fetching a messing key', function (done) {
client.hgetall('missing', function (err, obj) {
it('handles fetching a messing key', (done) => {
client.hgetall('missing', (err, obj) => {
assert.strictEqual(null, obj)
done(err)
})
})
})
describe('binary client', function () {
var client
var args = config.configureClient(ip, {
describe('binary client', () => {
let client
const args = config.configureClient(ip, {
returnBuffers: true
})
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns binary results', function (done) {
it('returns binary results', (done) => {
client.hmset(['bhosts', 'mjr', '1', 'another', '23', 'home', '1234', Buffer.from([0xAA, 0xBB, 0x00, 0xF0]), Buffer.from([0xCC, 0xDD, 0x00, 0xF0])], helper.isString('OK'))
client.hgetall('bhosts', function (err, obj) {
client.hgetall('bhosts', (err, obj) => {
assert.strictEqual(4, Object.keys(obj).length)
assert.strictEqual('1', obj.mjr.toString())
assert.strictEqual('23', obj.another.toString())
@@ -74,7 +74,7 @@ describe('The \'hgetall\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

30
test/commands/hincrby.spec.js
View File

@@ -1,36 +1,36 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hincrby\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var hash = 'test hash'
describe('The \'hincrby\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
const hash = 'test hash'
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('increments a key that has already been set', function (done) {
var field = 'field 1'
it('increments a key that has already been set', (done) => {
const field = 'field 1'
client.hset(hash, field, 33)
client.hincrby(hash, field, 10, helper.isNumber(43, done))
})
it('increments a key that has not been set', function (done) {
var field = 'field 2'
it('increments a key that has not been set', (done) => {
const field = 'field 2'
client.hincrby(hash, field, 10, helper.isNumber(10, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

34
test/commands/hlen.spec.js
View File

@@ -1,35 +1,35 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hlen\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'hlen\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('reports the count of keys', function (done) {
var hash = 'test hash'
var field1 = Buffer.from('0123456789')
var value1 = Buffer.from('abcdefghij')
var field2 = Buffer.from('')
var value2 = Buffer.from('')
it('reports the count of keys', (done) => {
const hash = 'test hash'
const field1 = Buffer.from('0123456789')
const value1 = Buffer.from('abcdefghij')
const field2 = Buffer.from('')
const value2 = Buffer.from('')
client.hset(hash, field1, value1, helper.isNumber(1))
client.hset(hash, field2, value2, helper.isNumber(1))
client.hlen(hash, helper.isNumber(2, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

46
test/commands/hmget.spec.js
View File

@@ -1,36 +1,36 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hmget\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var hash = 'test hash'
describe('The \'hmget\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
const hash = 'test hash'
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb()
client.hmset(hash, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value'}, helper.isString('OK', done))
})
})
it('allows keys to be specified using multiple arguments', function (done) {
client.hmget(hash, '0123456789', 'some manner of key', function (err, reply) {
it('allows keys to be specified using multiple arguments', (done) => {
client.hmget(hash, '0123456789', 'some manner of key', (err, reply) => {
assert.strictEqual('abcdefghij', reply[0].toString())
assert.strictEqual('a type of value', reply[1].toString())
return done(err)
})
})
it('allows keys to be specified by passing an array without manipulating the array', function (done) {
var data = ['0123456789', 'some manner of key']
client.hmget(hash, data, function (err, reply) {
it('allows keys to be specified by passing an array without manipulating the array', (done) => {
const data = ['0123456789', 'some manner of key']
client.hmget(hash, data, (err, reply) => {
assert.strictEqual(data.length, 2)
assert.strictEqual('abcdefghij', reply[0].toString())
assert.strictEqual('a type of value', reply[1].toString())
@@ -38,30 +38,30 @@ describe('The \'hmget\' method', function () {
})
})
it('allows keys to be specified by passing an array as first argument', function (done) {
client.hmget([hash, '0123456789', 'some manner of key'], function (err, reply) {
it('allows keys to be specified by passing an array as first argument', (done) => {
client.hmget([hash, '0123456789', 'some manner of key'], (err, reply) => {
assert.strictEqual('abcdefghij', reply[0].toString())
assert.strictEqual('a type of value', reply[1].toString())
return done(err)
})
})
it('allows a single key to be specified in an array', function (done) {
client.hmget(hash, ['0123456789'], function (err, reply) {
it('allows a single key to be specified in an array', (done) => {
client.hmget(hash, ['0123456789'], (err, reply) => {
assert.strictEqual('abcdefghij', reply[0].toString())
return done(err)
})
})
it('allows keys to be specified that have not yet been set', function (done) {
client.hmget(hash, 'missing thing', 'another missing thing', function (err, reply) {
it('allows keys to be specified that have not yet been set', (done) => {
client.hmget(hash, 'missing thing', 'another missing thing', (err, reply) => {
assert.strictEqual(null, reply[0])
assert.strictEqual(null, reply[1])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

64
test/commands/hmset.spec.js
View File

@@ -1,113 +1,113 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hmset\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var hash = 'test hash'
describe('The \'hmset\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
const hash = 'test hash'
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('handles redis-style syntax', function (done) {
it('handles redis-style syntax', (done) => {
client.hmset(hash, '0123456789', 'abcdefghij', 'some manner of key', 'a type of value', 'otherTypes', 555, helper.isString('OK'))
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['0123456789'], 'abcdefghij')
assert.strictEqual(obj['some manner of key'], 'a type of value')
return done(err)
})
})
it('handles object-style syntax', function (done) {
it('handles object-style syntax', (done) => {
client.hmset(hash, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value', 'otherTypes': 555}, helper.isString('OK'))
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['0123456789'], 'abcdefghij')
assert.strictEqual(obj['some manner of key'], 'a type of value')
return done(err)
})
})
it('handles object-style syntax and the key being a number', function (done) {
it('handles object-style syntax and the key being a number', (done) => {
client.hmset(231232, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value', 'otherTypes': 555}, undefined)
client.hgetall(231232, function (err, obj) {
client.hgetall(231232, (err, obj) => {
assert.strictEqual(obj['0123456789'], 'abcdefghij')
assert.strictEqual(obj['some manner of key'], 'a type of value')
return done(err)
})
})
it('allows a numeric key', function (done) {
it('allows a numeric key', (done) => {
client.hmset(hash, 99, 'banana', helper.isString('OK'))
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
return done(err)
})
})
it('allows a numeric key without callback', function (done) {
it('allows a numeric key without callback', (done) => {
client.hmset(hash, 99, 'banana', 'test', 25)
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
assert.strictEqual(obj.test, '25')
return done(err)
})
})
it('allows an array without callback', function (done) {
it('allows an array without callback', (done) => {
client.hmset([hash, 99, 'banana', 'test', 25])
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
assert.strictEqual(obj.test, '25')
return done(err)
})
})
it('allows an array and a callback', function (done) {
it('allows an array and a callback', (done) => {
client.hmset([hash, 99, 'banana', 'test', 25], helper.isString('OK'))
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
assert.strictEqual(obj.test, '25')
return done(err)
})
})
it('allows a key plus array without callback', function (done) {
it('allows a key plus array without callback', (done) => {
client.hmset(hash, [99, 'banana', 'test', 25])
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
assert.strictEqual(obj.test, '25')
return done(err)
})
})
it('allows a key plus array and a callback', function (done) {
it('allows a key plus array and a callback', (done) => {
client.hmset(hash, [99, 'banana', 'test', 25], helper.isString('OK'))
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['99'], 'banana')
assert.strictEqual(obj.test, '25')
return done(err)
})
})
it('handles object-style syntax without callback', function (done) {
it('handles object-style syntax without callback', (done) => {
client.hmset(hash, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value'})
client.hgetall(hash, function (err, obj) {
client.hgetall(hash, (err, obj) => {
assert.strictEqual(obj['0123456789'], 'abcdefghij')
assert.strictEqual(obj['some manner of key'], 'a type of value')
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

89
test/commands/hset.spec.js
View File

@@ -1,89 +1,80 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'hset\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
var hash = 'test hash'
describe('The \'hset\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
const hash = 'test hash'
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('allows a value to be set in a hash', function (done) {
var field = Buffer.from('0123456789')
var value = Buffer.from('abcdefghij')
it('allows a value to be set in a hash', (done) => {
const field = Buffer.from('0123456789')
const value = Buffer.from('abcdefghij')
client.hset(hash, field, value, helper.isNumber(1))
client.hget(hash, field, helper.isString(value.toString(), done))
})
it('handles an empty value', function (done) {
var field = Buffer.from('0123456789')
var value = Buffer.from('')
it('handles an empty value', (done) => {
const field = Buffer.from('0123456789')
const value = Buffer.from('')
client.hset(hash, field, value, helper.isNumber(1))
client.hget([hash, field], helper.isString('', done))
})
it('handles empty key and value', function (done) {
var field = Buffer.from('')
var value = Buffer.from('')
client.hset([hash, field, value], function (err, res) {
it('handles empty key and value', (done) => {
const field = Buffer.from('')
const value = Buffer.from('')
client.hset([hash, field, value], (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 1)
client.hset(hash, field, value, helper.isNumber(0, done))
})
})
it('warns if someone passed a array either as field or as value', function (done) {
var hash = 'test hash'
var field = 'array'
it('warns if someone passed a array either as field or as value', (done) => {
const hash = 'test hash'
const field = 'array'
// This would be converted to "array contents" but if you use more than one entry,
// it'll result in e.g. "array contents,second content" and this is not supported and considered harmful
var value = ['array contents']
client.on('warning', function (msg) {
assert.strictEqual(
msg,
'Deprecated: The HMSET command contains a argument of type Array.\n' +
'This is converted to "array contents" by using .toString() now and will return an error from v.3.0 on.\n' +
'Please handle this in your code to make sure everything works as you intended it to.'
)
done()
})
client.hmset(hash, field, value)
const value = ['array contents']
client.hmset(hash, field, value, helper.isError(done))
})
it('does not error when a buffer and date are set as values on the same hash', function (done) {
var hash = 'test hash'
var field1 = 'buffer'
var value1 = Buffer.from('abcdefghij')
var field2 = 'date'
var value2 = new Date()
it('does not error when a buffer and date are set as values on the same hash', (done) => {
const hash = 'test hash'
const field1 = 'buffer'
const value1 = Buffer.from('abcdefghij')
const field2 = 'date'
const value2 = new Date()
client.hmset(hash, field1, value1, field2, value2, helper.isString('OK', done))
})
it('does not error when a buffer and date are set as fields on the same hash', function (done) {
var hash = 'test hash'
var value1 = 'buffer'
var field1 = Buffer.from('abcdefghij')
var value2 = 'date'
var field2 = new Date()
it('does not error when a buffer and date are set as fields on the same hash', (done) => {
const hash = 'test hash'
const value1 = 'buffer'
const field1 = Buffer.from('abcdefghij')
const value2 = 'date'
const field2 = new Date()
client.hmset(hash, field1, value1, field2, value2, helper.isString('OK', done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

30
test/commands/incr.spec.js
View File

@@ -1,18 +1,18 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'incr\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
describe('when connected and a value in Redis', function () {
var client
var key = 'ABOVE_SAFE_JAVASCRIPT_INTEGER'
describe('The \'incr\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
describe('when connected and a value in Redis', () => {
let client
const key = 'ABOVE_SAFE_JAVASCRIPT_INTEGER'
afterEach(function () {
afterEach(() => {
client.end(true)
})
@@ -27,7 +27,7 @@ describe('The \'incr\' method', function () {
9007199254740997 -> 9007199254740996
...
*/
it('count above the safe integers as numbers', function (done) {
it('count above the safe integers as numbers', (done) => {
client = redis.createClient.apply(null, args)
// Set a value to the maximum safe allowed javascript number (2^53) - 1
client.set(key, Number.MAX_SAFE_INTEGER, helper.isNotError())
@@ -36,7 +36,7 @@ describe('The \'incr\' method', function () {
client.incr(key, helper.isNumber(Number.MAX_SAFE_INTEGER + 3))
client.incr(key, helper.isNumber(Number.MAX_SAFE_INTEGER + 4))
client.incr(key, helper.isNumber(Number.MAX_SAFE_INTEGER + 5))
client.incr(key, function (err, res) {
client.incr(key, (err, res) => {
helper.isNumber(Number.MAX_SAFE_INTEGER + 6)(err, res)
assert.strictEqual(typeof res, 'number')
})
@@ -46,7 +46,7 @@ describe('The \'incr\' method', function () {
client.incr(key, helper.isNumber(Number.MAX_SAFE_INTEGER + 10, done))
})
it('count above the safe integers as strings', function (done) {
it('count above the safe integers as strings', (done) => {
args[2].stringNumbers = true
client = redis.createClient.apply(null, args)
// Set a value to the maximum safe allowed javascript number (2^53)
@@ -56,7 +56,7 @@ describe('The \'incr\' method', function () {
client.incr(key, helper.isString('9007199254740994'))
client.incr(key, helper.isString('9007199254740995'))
client.incr(key, helper.isString('9007199254740996'))
client.incr(key, function (err, res) {
client.incr(key, (err, res) => {
helper.isString('9007199254740997')(err, res)
assert.strictEqual(typeof res, 'string')
})

44
test/commands/info.spec.js
View File

@@ -1,50 +1,50 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'info\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'info\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushall(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('update serverInfo after a info command', function (done) {
it('update serverInfo after a info command', (done) => {
client.set('foo', 'bar')
client.info()
client.select(2, function () {
client.select(2, () => {
assert.strictEqual(client.serverInfo.db2, undefined)
})
client.set('foo', 'bar')
client.info()
setTimeout(function () {
setTimeout(() => {
assert.strictEqual(typeof client.serverInfo.db2, 'object')
done()
}, 30)
})
it('works with optional section provided with and without callback', function (done) {
it('works with optional section provided with and without callback', (done) => {
client.set('foo', 'bar')
client.info('keyspace')
client.select(2, function () {
client.select(2, () => {
assert.strictEqual(Object.keys(client.serverInfo).length, 2, 'Key length should be three')
assert.strictEqual(typeof client.serverInfo.db0, 'object', 'db0 keyspace should be an object')
})
client.info(['keyspace'])
client.set('foo', 'bar')
client.info('all', function (err, res) {
client.info('all', (err, res) => {
assert.strictEqual(err, null)
assert(Object.keys(client.serverInfo).length > 3, 'Key length should be way above three')
assert.strictEqual(typeof client.serverInfo.redis_version, 'string')
@@ -53,20 +53,20 @@ describe('The \'info\' method', function () {
})
})
it('check redis v.2.4 support', function (done) {
var end = helper.callFuncAfter(done, 2)
it('check redis v.2.4 support', (done) => {
const end = helper.callFuncAfter(done, 2)
client.internalSendCommand = function (commandObj) {
assert.strictEqual(commandObj.args.length, 0)
assert.strictEqual(commandObj.command, 'info')
end()
}
client.info()
client.info(function () {})
client.info(() => {})
})
it('emit error after a failure', function (done) {
it('emit error after a failure', (done) => {
client.info()
client.once('error', function (err) {
client.once('error', (err) => {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
assert.strictEqual(err.command, 'INFO')
done()

50
test/commands/keys.spec.js
View File

@@ -1,26 +1,26 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var crypto = require('crypto')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const crypto = require('crypto')
const helper = require('../helper')
const redis = config.redis
describe('The \'keys\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'keys\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushall(done)
})
})
it('returns matching keys', function (done) {
it('returns matching keys', (done) => {
client.mset(['test keys 1', 'test val 1', 'test keys 2', 'test val 2'], helper.isString('OK'))
client.keys('test keys*', function (err, results) {
client.keys('test keys*', (err, results) => {
assert.strictEqual(2, results.length)
assert.ok(~results.indexOf('test keys 1'))
assert.ok(~results.indexOf('test keys 2'))
@@ -28,38 +28,38 @@ describe('The \'keys\' method', function () {
})
})
it('handles a large packet size', function (done) {
var keysValues = []
it('handles a large packet size', (done) => {
const keysValues = []
for (var i = 0; i < 200; i++) {
var keyValue = [
'multibulk:' + crypto.randomBytes(256).toString('hex'), // use long strings as keys to ensure generation of large packet
'test val ' + i
for (let i = 0; i < 200; i++) {
const keyValue = [
`multibulk:${crypto.randomBytes(256).toString('hex')}`, // use long strings as keys to ensure generation of large packet
`test val ${i}`
]
keysValues.push(keyValue)
}
client.mset(keysValues.reduce(function (a, b) {
client.mset(keysValues.reduce((a, b) => {
return a.concat(b)
}), helper.isString('OK'))
client.keys('multibulk:*', function (err, results) {
assert.deepEqual(keysValues.map(function (val) {
client.keys('multibulk:*', (err, results) => {
assert.deepEqual(keysValues.map((val) => {
return val[0]
}).sort(), results.sort())
return done(err)
})
})
it('handles an empty response', function (done) {
client.keys(['users:*'], function (err, results) {
it('handles an empty response', (done) => {
client.keys(['users:*'], (err, results) => {
assert.strictEqual(results.length, 0)
assert.ok(Array.isArray(results))
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

38
test/commands/mget.spec.js
View File

@@ -1,27 +1,27 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'mget\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'mget\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb()
client.mset(['mget keys 1', 'mget val 1', 'mget keys 2', 'mget val 2', 'mget keys 3', 'mget val 3'], done)
})
})
it('handles fetching multiple keys in argument form', function (done) {
it('handles fetching multiple keys in argument form', (done) => {
client.mset(['mget keys 1', 'mget val 1', 'mget keys 2', 'mget val 2', 'mget keys 3', 'mget val 3'], helper.isString('OK'))
client.mget('mget keys 1', 'mget keys 2', 'mget keys 3', function (err, results) {
client.mget('mget keys 1', 'mget keys 2', 'mget keys 3', (err, results) => {
assert.strictEqual(3, results.length)
assert.strictEqual('mget val 1', results[0].toString())
assert.strictEqual('mget val 2', results[1].toString())
@@ -30,8 +30,8 @@ describe('The \'mget\' method', function () {
})
})
it('handles fetching multiple keys via an array', function (done) {
client.mget(['mget keys 1', 'mget keys 2', 'mget keys 3'], function (err, results) {
it('handles fetching multiple keys via an array', (done) => {
client.mget(['mget keys 1', 'mget keys 2', 'mget keys 3'], (err, results) => {
assert.strictEqual('mget val 1', results[0].toString())
assert.strictEqual('mget val 2', results[1].toString())
assert.strictEqual('mget val 3', results[2].toString())
@@ -39,8 +39,8 @@ describe('The \'mget\' method', function () {
})
})
it('handles fetching multiple keys, when some keys do not exist', function (done) {
client.mget('mget keys 1', ['some random shit', 'mget keys 2', 'mget keys 3'], function (err, results) {
it('handles fetching multiple keys, when some keys do not exist', (done) => {
client.mget('mget keys 1', ['some random shit', 'mget keys 2', 'mget keys 3'], (err, results) => {
assert.strictEqual(4, results.length)
assert.strictEqual('mget val 1', results[0].toString())
assert.strictEqual(null, results[1])
@@ -50,8 +50,8 @@ describe('The \'mget\' method', function () {
})
})
it('handles fetching multiple keys, when some keys do not exist promisified', function () {
return client.mgetAsync('mget keys 1', ['some random shit', 'mget keys 2', 'mget keys 3']).then(function (results) {
it('handles fetching multiple keys, when some keys do not exist promisified', () => {
return client.mgetAsync('mget keys 1', ['some random shit', 'mget keys 2', 'mget keys 3']).then((results) => {
assert.strictEqual(4, results.length)
assert.strictEqual('mget val 1', results[0].toString())
assert.strictEqual(null, results[1])
@@ -60,7 +60,7 @@ describe('The \'mget\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

100
test/commands/monitor.spec.js
View File

@@ -1,30 +1,30 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var utils = require('../../lib/utils')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const utils = require('../../lib/utils')
const redis = config.redis
describe('The \'monitor\' method', function () {
helper.allTests(function (parser, ip, args) {
var client
describe('The \'monitor\' method', () => {
helper.allTests((parser, ip, args) => {
let client
afterEach(function () {
afterEach(() => {
client.end(true)
})
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('connect', function () {
client.once('connect', () => {
client.flushdb(done)
})
})
it('monitors commands on all redis clients and works in the correct order', function (done) {
var monitorClient = redis.createClient.apply(null, args)
var responses = [
it('monitors commands on all redis clients and works in the correct order', (done) => {
const monitorClient = redis.createClient.apply(null, args)
const responses = [
['mget', 'some', 'keys', 'foo', 'bar'],
['set', 'json', '{"foo":"123","bar":"sdflkdfsjk","another":false}'],
['eval', 'return redis.call(\'set\', \'sha\', \'test\')', '0'],
@@ -34,11 +34,11 @@ describe('The \'monitor\' method', function () {
['mget', 'foo', 'baz'],
['subscribe', 'foo', 'baz']
]
var end = helper.callFuncAfter(done, 5)
const end = helper.callFuncAfter(done, 5)
monitorClient.set('foo', 'bar')
monitorClient.flushdb()
monitorClient.monitor(function (err, res) {
monitorClient.monitor((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'OK')
client.mget('some', 'keys', 'foo', 'bar')
@@ -48,20 +48,20 @@ describe('The \'monitor\' method', function () {
another: false
}))
client.eval('return redis.call(\'set\', \'sha\', \'test\')', 0)
monitorClient.get('baz', function (err, res) {
monitorClient.get('baz', (err, res) => {
assert.strictEqual(res, null)
end(err)
})
monitorClient.set('foo', 'bar" "s are " " good!"', function (err, res) {
monitorClient.set('foo', 'bar" "s are " " good!"', (err, res) => {
assert.strictEqual(res, 'OK')
end(err)
})
monitorClient.mget('foo', 'baz', function (err, res) {
monitorClient.mget('foo', 'baz', (err, res) => {
assert.strictEqual(res[0], 'bar" "s are " " good!"')
assert.strictEqual(res[1], null)
end(err)
})
monitorClient.subscribe('foo', 'baz', function (err, res) {
monitorClient.subscribe('foo', 'baz', (err, res) => {
// The return value might change in v.3
// assert.strictEqual(res, 'baz');
// TODO: Fix the return value of subscribe calls
@@ -69,7 +69,7 @@ describe('The \'monitor\' method', function () {
})
})
monitorClient.on('monitor', function (time, args, rawOutput) {
monitorClient.on('monitor', (time, args, rawOutput) => {
assert.strictEqual(monitorClient.monitoring, true)
assert.deepEqual(args, responses.shift())
assert(utils.monitorRegex.test(rawOutput), rawOutput)
@@ -83,19 +83,19 @@ describe('The \'monitor\' method', function () {
if (process.platform === 'win32') {
this.skip()
}
var monitorClient = redis.createClient({
const monitorClient = redis.createClient({
returnBuffers: true,
path: '/tmp/redis.sock'
})
monitorClient.monitor(function (err, res) {
monitorClient.monitor((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(monitorClient.monitoring, true)
assert.strictEqual(res.inspect(), Buffer.from('OK').inspect())
monitorClient.mget('hello', Buffer.from('world'))
})
monitorClient.on('monitor', function (time, args, rawOutput) {
monitorClient.on('monitor', (time, args, rawOutput) => {
assert.strictEqual(typeof rawOutput, 'string')
assert(utils.monitorRegex.test(rawOutput), rawOutput)
assert.deepEqual(args, ['mget', 'hello', 'world'])
@@ -104,11 +104,11 @@ describe('The \'monitor\' method', function () {
})
})
it('monitors reconnects properly and works with the offline queue', function (done) {
var called = false
it('monitors reconnects properly and works with the offline queue', (done) => {
let called = false
client.monitor(helper.isString('OK'))
client.mget('hello', 'world')
client.on('monitor', function (time, args, rawOutput) {
client.on('monitor', (time, args, rawOutput) => {
assert.strictEqual(client.monitoring, true)
assert(utils.monitorRegex.test(rawOutput), rawOutput)
assert.deepEqual(args, ['mget', 'hello', 'world'])
@@ -122,13 +122,13 @@ describe('The \'monitor\' method', function () {
})
})
it('monitors reconnects properly and works with the offline queue in a batch statement', function (done) {
var called = false
var multi = client.batch()
it('monitors reconnects properly and works with the offline queue in a batch statement', (done) => {
let called = false
const multi = client.batch()
multi.monitor(helper.isString('OK'))
multi.mget('hello', 'world')
multi.exec(helper.isDeepEqual(['OK', [null, null]]))
client.on('monitor', function (time, args, rawOutput) {
client.on('monitor', (time, args, rawOutput) => {
assert.strictEqual(client.monitoring, true)
assert(utils.monitorRegex.test(rawOutput), rawOutput)
assert.deepEqual(args, ['mget', 'hello', 'world'])
@@ -142,19 +142,19 @@ describe('The \'monitor\' method', function () {
})
})
it('monitor activates even if the command could not be processed properly after a reconnect', function (done) {
client.monitor(function (err, res) {
it('monitor activates even if the command could not be processed properly after a reconnect', (done) => {
client.monitor((err, res) => {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
})
client.on('error', function () {}) // Ignore error here
client.on('error', () => {}) // Ignore error here
client.stream.destroy()
var end = helper.callFuncAfter(done, 2)
client.on('monitor', function (time, args, rawOutput) {
const end = helper.callFuncAfter(done, 2)
client.on('monitor', (time, args, rawOutput) => {
assert.strictEqual(client.monitoring, true)
end()
})
client.on('reconnecting', function () {
client.get('foo', function (err, res) {
client.on('reconnecting', () => {
client.get('foo', (err, res) => {
assert(!err)
assert.strictEqual(client.monitoring, true)
end()
@@ -162,8 +162,8 @@ describe('The \'monitor\' method', function () {
})
})
it('monitors works in combination with the pub sub mode and the offline queue', function (done) {
var responses = [
it('monitors works in combination with the pub sub mode and the offline queue', (done) => {
const responses = [
['subscribe', '/foo', '/bar'],
['unsubscribe', '/bar'],
['get', 'foo'],
@@ -172,39 +172,39 @@ describe('The \'monitor\' method', function () {
['unsubscribe', 'baz'],
['publish', '/foo', 'hello world']
]
var pub = redis.createClient()
pub.on('ready', function () {
client.monitor(function (err, res) {
const pub = redis.createClient()
pub.on('ready', () => {
client.monitor((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'OK')
pub.get('foo', helper.isNull())
})
client.subscribe('/foo', '/bar')
client.unsubscribe('/bar')
setTimeout(function () {
setTimeout(() => {
client.stream.destroy()
client.once('ready', function () {
client.once('ready', () => {
pub.publish('/foo', 'hello world')
})
client.set('foo', 'bar', helper.isError())
client.subscribe('baz')
client.unsubscribe('baz')
}, 150)
var called = false
client.on('monitor', function (time, args, rawOutput) {
let called = false
client.on('monitor', (time, args, rawOutput) => {
assert.deepEqual(args, responses.shift())
assert(utils.monitorRegex.test(rawOutput), rawOutput)
if (responses.length === 0) {
// The publish is called right after the reconnect and the monitor is called before the message is emitted.
// Therefore we have to wait till the next tick
process.nextTick(function () {
process.nextTick(() => {
assert(called)
client.quit(done)
pub.end(false)
})
}
})
client.on('message', function (channel, msg) {
client.on('message', (channel, msg) => {
assert.strictEqual(channel, '/foo')
assert.strictEqual(msg, 'hello world')
called = true

70
test/commands/mset.spec.js
View File

@@ -1,60 +1,60 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'mset\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, value, key2, value2
describe('The \'mset\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, value, key2, value2
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
value = uuid.v4()
key2 = uuid.v4()
value2 = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.mset(key, value, key2, value2, function (err, res) {
it('reports an error', (done) => {
client.mset(key, value, key2, value2, (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('and a callback is specified', function () {
describe('with valid parameters', function () {
it('sets the value correctly', function (done) {
client.mset(key, value, key2, value2, function (err) {
describe('and a callback is specified', () => {
describe('with valid parameters', () => {
it('sets the value correctly', (done) => {
client.mset(key, value, key2, value2, (err) => {
if (err) {
return done(err)
}
@@ -64,9 +64,9 @@ describe('The \'mset\' method', function () {
})
})
describe('with undefined \'key\' parameter and missing \'value\' parameter', function () {
it('reports an error', function (done) {
client.mset(undefined, function (err, res) {
describe('with undefined \'key\' parameter and missing \'value\' parameter', () => {
it('reports an error', (done) => {
client.mset(undefined, (err, res) => {
helper.isError()(err, null)
done()
})
@@ -74,25 +74,25 @@ describe('The \'mset\' method', function () {
})
})
describe('and no callback is specified', function () {
describe('with valid parameters', function () {
it('sets the value correctly', function (done) {
describe('and no callback is specified', () => {
describe('with valid parameters', () => {
it('sets the value correctly', (done) => {
client.mset(key, value2, key2, value)
client.get(key, helper.isString(value2))
client.get(key2, helper.isString(value, done))
})
it('sets the value correctly with array syntax', function (done) {
it('sets the value correctly with array syntax', (done) => {
client.mset([key, value2, key2, value])
client.get(key, helper.isString(value2))
client.get(key2, helper.isString(value, done))
})
})
describe('with undefined \'key\' and missing \'value\' parameter', function () {
describe('with undefined \'key\' and missing \'value\' parameter', () => {
// this behavior is different from the 'set' behavior.
it('emits an error', function (done) {
client.on('error', function (err) {
it('emits an error', (done) => {
client.on('error', (err) => {
assert.strictEqual(err.message, 'ERR wrong number of arguments for \'mset\' command')
assert.strictEqual(err.name, 'ReplyError')
done()

24
test/commands/msetnx.spec.js
View File

@@ -1,34 +1,34 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'msetnx\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'msetnx\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('if any keys exist entire operation fails', function (done) {
it('if any keys exist entire operation fails', (done) => {
client.mset(['mset1', 'val1', 'mset2', 'val2', 'mset3', 'val3'], helper.isString('OK'))
client.msetnx(['mset3', 'val3', 'mset4', 'val4'], helper.isNumber(0))
client.exists(['mset4'], helper.isNumber(0, done))
})
it('sets multiple keys if all keys are not set', function (done) {
it('sets multiple keys if all keys are not set', (done) => {
client.msetnx(['mset3', 'val3', 'mset4', 'val4'], helper.isNumber(1))
client.exists(['mset3'], helper.isNumber(1))
client.exists(['mset3'], helper.isNumber(1, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/randomkey.test.js
View File

@@ -1,31 +1,31 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'randomkey\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'randomkey\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns a random key', function (done) {
it('returns a random key', (done) => {
client.mset(['test keys 1', 'test val 1', 'test keys 2', 'test val 2'], helper.isString('OK'))
client.randomkey([], function (err, results) {
client.randomkey([], (err, results) => {
assert.strictEqual(true, /test keys.+/.test(results))
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

24
test/commands/rename.spec.js
View File

@@ -1,34 +1,34 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'rename\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'rename\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('populates the new key', function (done) {
it('populates the new key', (done) => {
client.set(['foo', 'bar'], helper.isString('OK'))
client.rename(['foo', 'new foo'], helper.isString('OK'))
client.exists(['new foo'], helper.isNumber(1, done))
})
it('removes the old key', function (done) {
it('removes the old key', (done) => {
client.set(['foo', 'bar'], helper.isString('OK'))
client.rename(['foo', 'new foo'], helper.isString('OK'))
client.exists(['foo'], helper.isNumber(0, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

24
test/commands/renamenx.spec.js
View File

@@ -1,29 +1,29 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'renamenx\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'renamenx\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('renames the key if target does not yet exist', function (done) {
it('renames the key if target does not yet exist', (done) => {
client.set('foo', 'bar', helper.isString('OK'))
client.renamenx('foo', 'foo2', helper.isNumber(1))
client.exists('foo', helper.isNumber(0))
client.exists(['foo2'], helper.isNumber(1, done))
})
it('does not rename the key if the target exists', function (done) {
it('does not rename the key if the target exists', (done) => {
client.set('foo', 'bar', helper.isString('OK'))
client.set('foo2', 'apple', helper.isString('OK'))
client.renamenx('foo', 'foo2', helper.isNumber(0))
@@ -31,7 +31,7 @@ describe('The \'renamenx\' method', function () {
client.exists(['foo2'], helper.isNumber(1, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/rpush.spec.js
View File

@@ -1,32 +1,32 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const assert = require('assert')
describe('The \'rpush\' command', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'rpush\' command', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('inserts multiple values at a time into a list', function (done) {
it('inserts multiple values at a time into a list', (done) => {
client.rpush('test', ['list key', 'should be a list'])
client.lrange('test', 0, -1, function (err, res) {
client.lrange('test', 0, -1, (err, res) => {
assert.strictEqual(res[0], 'list key')
assert.strictEqual(res[1], 'should be a list')
done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

36
test/commands/sadd.spec.js
View File

@@ -1,38 +1,38 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sadd\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sadd\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('allows a single value to be added to the set', function (done) {
it('allows a single value to be added to the set', (done) => {
client.sadd('set0', 'member0', helper.isNumber(1))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.ok(~res.indexOf('member0'))
return done(err)
})
})
it('does not add the same value to the set twice', function (done) {
it('does not add the same value to the set twice', (done) => {
client.sadd('set0', 'member0', helper.isNumber(1))
client.sadd('set0', 'member0', helper.isNumber(0, done))
})
it('allows multiple values to be added to the set', function (done) {
it('allows multiple values to be added to the set', (done) => {
client.sadd('set0', ['member0', 'member1', 'member2'], helper.isNumber(3))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.strictEqual(res.length, 3)
assert.ok(~res.indexOf('member0'))
assert.ok(~res.indexOf('member1'))
@@ -41,9 +41,9 @@ describe('The \'sadd\' method', function () {
})
})
it('allows multiple values to be added to the set with a different syntax', function (done) {
it('allows multiple values to be added to the set with a different syntax', (done) => {
client.sadd(['set0', 'member0', 'member1', 'member2'], helper.isNumber(3))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.strictEqual(res.length, 3)
assert.ok(~res.indexOf('member0'))
assert.ok(~res.indexOf('member1'))
@@ -52,7 +52,7 @@ describe('The \'sadd\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

22
test/commands/scard.spec.js
View File

@@ -1,27 +1,27 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'scard\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'scard\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns the number of values in a set', function (done) {
it('returns the number of values in a set', (done) => {
client.sadd('foo', [1, 2, 3], helper.isNumber(3))
client.scard('foo', helper.isNumber(3, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

34
test/commands/script.spec.js
View File

@@ -1,42 +1,42 @@
'use strict'
var config = require('../lib/config')
var crypto = require('crypto')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const crypto = require('crypto')
const helper = require('../helper')
const redis = config.redis
describe('The \'script\' method', function () {
helper.allTests(function (ip, args) {
var command = 'return 99'
var commandSha = crypto.createHash('sha1').update(command).digest('hex')
describe('The \'script\' method', () => {
helper.allTests((ip, args) => {
const command = 'return 99'
const commandSha = crypto.createHash('sha1').update(command).digest('hex')
describe('using ' + ip, function () {
var client
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('loads script with client.script(\'load\')', function (done) {
it('loads script with client.script(\'load\')', (done) => {
client.script('load', command, helper.isString(commandSha, done))
})
it('allows a loaded script to be evaluated', function (done) {
it('allows a loaded script to be evaluated', (done) => {
client.evalsha(commandSha, 0, helper.isNumber(99, done))
})
it('allows a script to be loaded as part of a chained transaction', function (done) {
it('allows a script to be loaded as part of a chained transaction', (done) => {
client.multi().script('load', command).exec(helper.isDeepEqual([commandSha], done))
})
it('allows a script to be loaded using a transaction\'s array syntax', function (done) {
it('allows a script to be loaded using a transaction\'s array syntax', (done) => {
client.multi([['script', 'load', command]]).exec(helper.isDeepEqual([commandSha], done))
})
})

26
test/commands/sdiff.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sdiff\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sdiff\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns set difference', function (done) {
it('returns set difference', (done) => {
client.sadd('foo', 'x', helper.isNumber(1))
client.sadd('foo', ['a'], helper.isNumber(1))
client.sadd('foo', 'b', helper.isNumber(1))
@@ -28,7 +28,7 @@ describe('The \'sdiff\' method', function () {
client.sadd('baz', 'a', helper.isNumber(1))
client.sadd('baz', 'd', helper.isNumber(1))
client.sdiff('foo', 'bar', 'baz', function (err, values) {
client.sdiff('foo', 'bar', 'baz', (err, values) => {
values.sort()
assert.strictEqual(values.length, 2)
assert.strictEqual(values[0], 'b')
@@ -37,7 +37,7 @@ describe('The \'sdiff\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

28
test/commands/sdiffstore.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sdiffstore\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sdiffstore\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('calculates set difference ands stores it in a key', function (done) {
it('calculates set difference ands stores it in a key', (done) => {
client.sadd('foo', 'x', helper.isNumber(1))
client.sadd('foo', 'a', helper.isNumber(1))
client.sadd('foo', 'b', helper.isNumber(1))
@@ -30,14 +30,14 @@ describe('The \'sdiffstore\' method', function () {
client.sdiffstore('quux', 'foo', 'bar', 'baz', helper.isNumber(2))
client.smembers('quux', function (err, values) {
var members = values.sort()
client.smembers('quux', (err, values) => {
const members = values.sort()
assert.deepEqual(members, [ 'b', 'x' ])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

78
test/commands/select.spec.js
View File

@@ -1,63 +1,61 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'select\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
describe('when not connected', function () {
var client
describe('The \'select\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('returns an error if redis is not connected', function (done) {
var buffering = client.select(1, function (err, res) {
it('returns an error if redis is not connected', (done) => {
client.select(1, (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
assert(typeof buffering === 'boolean')
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('changes the database and calls the callback', function (done) {
it('changes the database and calls the callback', (done) => {
// default value of null means database 0 will be used.
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
var buffering = client.select(1, function (err, res) {
client.select(1, (err, res) => {
helper.isNotError()(err, res)
assert.strictEqual(client.selectedDb, 1, 'db should be 1 after select')
done()
})
assert(typeof buffering === 'boolean')
})
describe('and a callback is specified', function () {
describe('with a valid db index', function () {
it('selects the appropriate database', function (done) {
describe('and a callback is specified', () => {
describe('with a valid db index', () => {
it('selects the appropriate database', (done) => {
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
client.select(1, function (err) {
client.select(1, (err) => {
assert.strictEqual(err, null)
assert.strictEqual(client.selectedDb, 1, 'we should have selected the new valid DB')
done()
@@ -65,10 +63,10 @@ describe('The \'select\' method', function () {
})
})
describe('with an invalid db index', function () {
it('returns an error', function (done) {
describe('with an invalid db index', () => {
it('returns an error', (done) => {
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
client.select(9999, function (err) {
client.select(9999, (err) => {
assert.strictEqual(err.code, 'ERR')
assert.strictEqual(err.message, 'ERR invalid DB index')
done()
@@ -77,23 +75,23 @@ describe('The \'select\' method', function () {
})
})
describe('and no callback is specified', function () {
describe('with a valid db index', function () {
it('selects the appropriate database', function (done) {
describe('and no callback is specified', () => {
describe('with a valid db index', () => {
it('selects the appropriate database', (done) => {
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
client.select(1)
setTimeout(function () {
setTimeout(() => {
assert.strictEqual(client.selectedDb, 1, 'we should have selected the new valid DB')
done()
}, 25)
})
})
describe('with an invalid db index', function () {
it('emits an error when callback not provided', function (done) {
describe('with an invalid db index', () => {
it('emits an error when callback not provided', (done) => {
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.command, 'SELECT')
assert.strictEqual(err.message, 'ERR invalid DB index')
done()
@@ -104,14 +102,14 @@ describe('The \'select\' method', function () {
})
})
describe('reconnection occurs', function () {
it('selects the appropriate database after a reconnect', function (done) {
describe('reconnection occurs', () => {
it('selects the appropriate database after a reconnect', (done) => {
assert.strictEqual(client.selectedDb, undefined, 'default db should be undefined')
client.select(3)
client.set('foo', 'bar', function () {
client.set('foo', 'bar', () => {
client.stream.destroy()
})
client.once('ready', function () {
client.once('ready', () => {
assert.strictEqual(client.selectedDb, 3)
assert(typeof client.serverInfo.db3 === 'object')
done()

104
test/commands/set.spec.js
View File

@@ -1,89 +1,89 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
var uuid = require('uuid')
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
const uuid = require('uuid')
describe('The \'set\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var key, value
describe('The \'set\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let key, value
beforeEach(function () {
beforeEach(() => {
key = uuid.v4()
value = uuid.v4()
})
describe('when not connected', function () {
var client
describe('when not connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit()
})
client.on('end', done)
})
it('reports an error', function (done) {
client.set(key, value, function (err, res) {
it('reports an error', (done) => {
client.set(key, value, (err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
})
})
describe('when connected', function () {
var client
describe('when connected', () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('and a callback is specified', function () {
describe('with valid parameters', function () {
it('sets the value correctly', function (done) {
client.set(key, value, function (err, res) {
describe('and a callback is specified', () => {
describe('with valid parameters', () => {
it('sets the value correctly', (done) => {
client.set(key, value, (err, res) => {
helper.isNotError()(err, res)
client.get(key, function (err, res) {
client.get(key, (err, res) => {
helper.isString(value)(err, res)
done()
})
})
})
it('set expire date in seconds', function (done) {
it('set expire date in seconds', (done) => {
client.set('foo', 'bar', 'ex', 10, helper.isString('OK'))
client.pttl('foo', function (err, res) {
client.pttl('foo', (err, res) => {
assert(res >= 10000 - 50) // Max 50 ms should have passed
assert(res <= 10000) // Max possible should be 10.000
done(err)
})
})
it('set expire date in milliseconds', function (done) {
it('set expire date in milliseconds', (done) => {
client.set('foo', 'bar', 'px', 100, helper.isString('OK'))
client.pttl('foo', function (err, res) {
client.pttl('foo', (err, res) => {
assert(res >= 50) // Max 50 ms should have passed
assert(res <= 100) // Max possible should be 100
done(err)
})
})
it('only set the key if (not) already set', function (done) {
it('only set the key if (not) already set', (done) => {
client.set('foo', 'bar', 'NX', helper.isString('OK'))
client.set('foo', 'bar', 'nx', helper.isNull())
client.set('foo', 'bar', 'EX', '10', 'XX', helper.isString('OK'))
client.ttl('foo', function (err, res) {
client.ttl('foo', (err, res) => {
assert(res >= 9) // Min 9s should be left
assert(res <= 10) // Max 10s should be left
done(err)
@@ -91,17 +91,17 @@ describe('The \'set\' method', function () {
})
})
describe('reports an error with invalid parameters', function () {
it('undefined \'key\' and missing \'value\' parameter', function (done) {
client.set(undefined, function (err, res) {
describe('reports an error with invalid parameters', () => {
it('undefined \'key\' and missing \'value\' parameter', (done) => {
client.set(undefined, (err, res) => {
helper.isError()(err, null)
assert.strictEqual(err.command, 'SET')
done()
})
})
it('empty array as second parameter', function (done) {
client.set('foo', [], function (err, res) {
it('empty array as second parameter', (done) => {
client.set('foo', [], (err, res) => {
assert.strictEqual(err.message, 'ERR wrong number of arguments for \'set\' command')
done()
})
@@ -109,27 +109,27 @@ describe('The \'set\' method', function () {
})
})
describe('and no callback is specified', function () {
describe('with valid parameters', function () {
it('sets the value correctly', function (done) {
describe('and no callback is specified', () => {
describe('with valid parameters', () => {
it('sets the value correctly', (done) => {
client.set(key, value)
client.get(key, helper.isString(value, done))
})
it('sets the value correctly even if the callback is explicitly set to undefined', function (done) {
it('sets the value correctly even if the callback is explicitly set to undefined', (done) => {
client.set(key, value, undefined)
client.get(key, helper.isString(value, done))
})
it('sets the value correctly with the array syntax', function (done) {
it('sets the value correctly with the array syntax', (done) => {
client.set([key, value])
client.get(key, helper.isString(value, done))
})
})
describe('with undefined \'key\' and missing \'value\' parameter', function () {
it('emits an error without callback', function (done) {
client.on('error', function (err) {
describe('with undefined \'key\' and missing \'value\' parameter', () => {
it('emits an error without callback', (done) => {
client.on('error', (err) => {
assert.strictEqual(err.message, 'ERR wrong number of arguments for \'set\' command')
assert.strictEqual(err.command, 'SET')
done()
@@ -138,14 +138,12 @@ describe('The \'set\' method', function () {
})
})
// TODO: This test has to be refactored from v.3.0 on to expect an error instead
it('converts null to \'null\'', function (done) {
client.set('foo', null)
client.get('foo', helper.isString('null', done))
it('returns an error on \'null\'', (done) => {
client.set('foo', null, helper.isError(done))
})
it('emit an error with only the key set', function (done) {
client.on('error', function (err) {
it('emit an error with only the key set', (done) => {
client.on('error', (err) => {
assert.strictEqual(err.message, 'ERR wrong number of arguments for \'set\' command')
done()
})
@@ -153,8 +151,8 @@ describe('The \'set\' method', function () {
client.set('foo')
})
it('emit an error without any parameters', function (done) {
client.once('error', function (err) {
it('emit an error without any parameters', (done) => {
client.once('error', (err) => {
assert.strictEqual(err.message, 'ERR wrong number of arguments for \'set\' command')
assert.strictEqual(err.command, 'SET')
done()

29
test/commands/setex.spec.js
View File

@@ -1,34 +1,33 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'setex\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'setex\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('sets a key with an expiry', function (done) {
it('sets a key with an expiry', (done) => {
client.setex(['setex key', '100', 'setex val'], helper.isString('OK'))
var buffering = client.exists(['setex key'], helper.isNumber(1))
assert(typeof buffering === 'boolean')
client.ttl(['setex key'], function (err, ttl) {
client.exists(['setex key'], helper.isNumber(1))
client.ttl(['setex key'], (err, ttl) => {
assert.strictEqual(err, null)
assert(ttl > 0)
return done()
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

24
test/commands/setnx.spec.js
View File

@@ -1,33 +1,33 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'setnx\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'setnx\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('sets key if it does not have a value', function (done) {
it('sets key if it does not have a value', (done) => {
client.setnx('foo', 'banana', helper.isNumber(1))
client.get('foo', helper.isString('banana', done))
})
it('does not set key if it already has a value', function (done) {
it('does not set key if it already has a value', (done) => {
client.set('foo', 'bar', helper.isString('OK'))
client.setnx('foo', 'banana', helper.isNumber(0))
client.get('foo', helper.isString('bar', done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

30
test/commands/sinter.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sinter\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sinter\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('handles two sets being intersected', function (done) {
it('handles two sets being intersected', (done) => {
client.sadd('sa', 'a', helper.isNumber(1))
client.sadd('sa', 'b', helper.isNumber(1))
client.sadd('sa', 'c', helper.isNumber(1))
@@ -26,14 +26,14 @@ describe('The \'sinter\' method', function () {
client.sadd('sb', 'c', helper.isNumber(1))
client.sadd('sb', 'd', helper.isNumber(1))
client.sinter('sa', 'sb', function (err, intersection) {
client.sinter('sa', 'sb', (err, intersection) => {
assert.strictEqual(intersection.length, 2)
assert.deepEqual(intersection.sort(), [ 'b', 'c' ])
return done(err)
})
})
it('handles three sets being intersected', function (done) {
it('handles three sets being intersected', (done) => {
client.sadd('sa', 'a', helper.isNumber(1))
client.sadd('sa', 'b', helper.isNumber(1))
client.sadd('sa', 'c', helper.isNumber(1))
@@ -46,14 +46,14 @@ describe('The \'sinter\' method', function () {
client.sadd('sc', 'd', helper.isNumber(1))
client.sadd('sc', 'e', helper.isNumber(1))
client.sinter('sa', 'sb', 'sc', function (err, intersection) {
client.sinter('sa', 'sb', 'sc', (err, intersection) => {
assert.strictEqual(intersection.length, 1)
assert.strictEqual(intersection[0], 'c')
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/sinterstore.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sinterstore\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sinterstore\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('calculates set intersection and stores it in a key', function (done) {
it('calculates set intersection and stores it in a key', (done) => {
client.sadd('sa', 'a', helper.isNumber(1))
client.sadd('sa', 'b', helper.isNumber(1))
client.sadd('sa', 'c', helper.isNumber(1))
@@ -32,13 +32,13 @@ describe('The \'sinterstore\' method', function () {
client.sinterstore('foo', 'sa', 'sb', 'sc', helper.isNumber(1))
client.smembers('foo', function (err, members) {
client.smembers('foo', (err, members) => {
assert.deepEqual(members, [ 'c' ])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

24
test/commands/sismember.spec.js
View File

@@ -1,31 +1,31 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sismember\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sismember\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns 0 if the value is not in the set', function (done) {
it('returns 0 if the value is not in the set', (done) => {
client.sismember('foo', 'banana', helper.isNumber(0, done))
})
it('returns 1 if the value is in the set', function (done) {
it('returns 1 if the value is in the set', (done) => {
client.sadd('foo', 'banana', helper.isNumber(1))
client.sismember('foo', 'banana', helper.isNumber(1, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/slowlog.spec.js
View File

@@ -1,28 +1,28 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'slowlog\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'slowlog\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('logs operations in slowlog', function (done) {
it('logs operations in slowlog', (done) => {
client.config('set', 'slowlog-log-slower-than', 0, helper.isString('OK'))
client.slowlog('reset', helper.isString('OK'))
client.set('foo', 'bar', helper.isString('OK'))
client.get('foo', helper.isString('bar'))
client.slowlog('get', function (err, res) {
client.slowlog('get', (err, res) => {
assert.strictEqual(res.length, 3)
assert.strictEqual(res[0][3].length, 2)
assert.deepEqual(res[1][3], ['set', 'foo', 'bar'])
@@ -31,7 +31,7 @@ describe('The \'slowlog\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

28
test/commands/smembers.spec.js
View File

@@ -1,34 +1,34 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'smembers\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'smembers\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns all values in a set', function (done) {
it('returns all values in a set', (done) => {
client.sadd('foo', 'x', helper.isNumber(1))
client.sadd('foo', 'y', helper.isNumber(1))
client.smembers('foo', function (err, values) {
client.smembers('foo', (err, values) => {
assert.strictEqual(values.length, 2)
var members = values.sort()
const members = values.sort()
assert.deepEqual(members, [ 'x', 'y' ])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

24
test/commands/smove.spec.js
View File

@@ -1,36 +1,36 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'smove\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'smove\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('moves a value to a set that does not yet exist', function (done) {
it('moves a value to a set that does not yet exist', (done) => {
client.sadd('foo', 'x', helper.isNumber(1))
client.smove('foo', 'bar', 'x', helper.isNumber(1))
client.sismember('foo', 'x', helper.isNumber(0))
client.sismember('bar', 'x', helper.isNumber(1, done))
})
it('does not move a value if it does not exist in the first set', function (done) {
it('does not move a value if it does not exist in the first set', (done) => {
client.sadd('foo', 'x', helper.isNumber(1))
client.smove('foo', 'bar', 'y', helper.isNumber(0))
client.sismember('foo', 'y', helper.isNumber(0))
client.sismember('bar', 'y', helper.isNumber(0, done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

66
test/commands/sort.spec.js
View File

@@ -1,9 +1,9 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
function setupData (client, done) {
client.rpush('y', 'd')
@@ -32,94 +32,94 @@ function setupData (client, done) {
client.set('p9', 'tux', done)
}
describe('The \'sort\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sort\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('error', done)
client.once('connect', function () {
client.once('connect', () => {
client.flushdb()
setupData(client, done)
})
})
describe('alphabetical', function () {
it('sorts in ascending alphabetical order', function (done) {
client.sort('y', 'asc', 'alpha', function (err, sorted) {
describe('alphabetical', () => {
it('sorts in ascending alphabetical order', (done) => {
client.sort('y', 'asc', 'alpha', (err, sorted) => {
assert.deepEqual(sorted, ['a', 'b', 'c', 'd'])
return done(err)
})
})
it('sorts in descending alphabetical order', function (done) {
client.sort('y', 'desc', 'alpha', function (err, sorted) {
it('sorts in descending alphabetical order', (done) => {
client.sort('y', 'desc', 'alpha', (err, sorted) => {
assert.deepEqual(sorted, ['d', 'c', 'b', 'a'])
return done(err)
})
})
})
describe('numeric', function () {
it('sorts in ascending numeric order', function (done) {
client.sort('x', 'asc', function (err, sorted) {
describe('numeric', () => {
it('sorts in ascending numeric order', (done) => {
client.sort('x', 'asc', (err, sorted) => {
assert.deepEqual(sorted, [2, 3, 4, 9])
return done(err)
})
})
it('sorts in descending numeric order', function (done) {
client.sort('x', 'desc', function (err, sorted) {
it('sorts in descending numeric order', (done) => {
client.sort('x', 'desc', (err, sorted) => {
assert.deepEqual(sorted, [9, 4, 3, 2])
return done(err)
})
})
})
describe('pattern', function () {
it('handles sorting with a pattern', function (done) {
client.sort('x', 'by', 'w*', 'asc', function (err, sorted) {
describe('pattern', () => {
it('handles sorting with a pattern', (done) => {
client.sort('x', 'by', 'w*', 'asc', (err, sorted) => {
assert.deepEqual(sorted, [3, 9, 4, 2])
return done(err)
})
})
it('handles sorting with a \'by\' pattern and 1 \'get\' pattern', function (done) {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', function (err, sorted) {
it('handles sorting with a \'by\' pattern and 1 \'get\' pattern', (done) => {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', (err, sorted) => {
assert.deepEqual(sorted, ['foo', 'bar', 'baz', 'buz'])
return done(err)
})
})
it('handles sorting with a \'by\' pattern and 2 \'get\' patterns', function (done) {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', function (err, sorted) {
it('handles sorting with a \'by\' pattern and 2 \'get\' patterns', (done) => {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', (err, sorted) => {
assert.deepEqual(sorted, ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'])
return done(err)
})
})
it('handles sorting with a \'by\' pattern and 2 \'get\' patterns with the array syntax', function (done) {
client.sort(['x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*'], function (err, sorted) {
it('handles sorting with a \'by\' pattern and 2 \'get\' patterns with the array syntax', (done) => {
client.sort(['x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*'], (err, sorted) => {
assert.deepEqual(sorted, ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'])
return done(err)
})
})
it('sorting with a \'by\' pattern and 2 \'get\' patterns and stores results', function (done) {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', 'store', 'bacon', function (err) {
it('sorting with a \'by\' pattern and 2 \'get\' patterns and stores results', (done) => {
client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', 'store', 'bacon', (err) => {
if (err) return done(err)
})
client.lrange('bacon', 0, -1, function (err, values) {
client.lrange('bacon', 0, -1, (err, values) => {
assert.deepEqual(values, ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'])
return done(err)
})
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/spop.spec.js
View File

@@ -1,34 +1,34 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'spop\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'spop\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns a random element from the set', function (done) {
it('returns a random element from the set', (done) => {
client.sadd('zzz', 'member0', helper.isNumber(1))
client.scard('zzz', helper.isNumber(1))
client.spop('zzz', function (err, value) {
client.spop('zzz', (err, value) => {
if (err) return done(err)
assert.strictEqual(value, 'member0')
client.scard('zzz', helper.isNumber(0, done))
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

38
test/commands/srem.spec.js
View File

@@ -1,56 +1,56 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'srem\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'srem\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('removes a value', function (done) {
it('removes a value', (done) => {
client.sadd('set0', 'member0', helper.isNumber(1))
client.srem('set0', 'member0', helper.isNumber(1))
client.scard('set0', helper.isNumber(0, done))
})
it('handles attempting to remove a missing value', function (done) {
it('handles attempting to remove a missing value', (done) => {
client.srem('set0', 'member0', helper.isNumber(0, done))
})
it('allows multiple values to be removed', function (done) {
it('allows multiple values to be removed', (done) => {
client.sadd('set0', ['member0', 'member1', 'member2'], helper.isNumber(3))
client.srem('set0', ['member1', 'member2'], helper.isNumber(2))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.strictEqual(res.length, 1)
assert.ok(~res.indexOf('member0'))
return done(err)
})
})
it('allows multiple values to be removed with sendCommand', function (done) {
it('allows multiple values to be removed with sendCommand', (done) => {
client.sendCommand('sadd', ['set0', 'member0', 'member1', 'member2'], helper.isNumber(3))
client.sendCommand('srem', ['set0', 'member1', 'member2'], helper.isNumber(2))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.strictEqual(res.length, 1)
assert.ok(~res.indexOf('member0'))
return done(err)
})
})
it('handles a value missing from the set of values being removed', function (done) {
it('handles a value missing from the set of values being removed', (done) => {
client.sadd(['set0', 'member0', 'member1', 'member2'], helper.isNumber(3))
client.srem(['set0', 'member3', 'member4'], helper.isNumber(0))
client.smembers('set0', function (err, res) {
client.smembers('set0', (err, res) => {
assert.strictEqual(res.length, 3)
assert.ok(~res.indexOf('member0'))
assert.ok(~res.indexOf('member1'))
@@ -59,7 +59,7 @@ describe('The \'srem\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/sunion.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sunion\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sunion\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns the union of a group of sets', function (done) {
it('returns the union of a group of sets', (done) => {
client.sadd('sa', 'a', helper.isNumber(1))
client.sadd('sa', 'b', helper.isNumber(1))
client.sadd('sa', 'c', helper.isNumber(1))
@@ -30,13 +30,13 @@ describe('The \'sunion\' method', function () {
client.sadd('sc', 'd', helper.isNumber(1))
client.sadd('sc', 'e', helper.isNumber(1))
client.sunion('sa', 'sb', 'sc', function (err, union) {
client.sunion('sa', 'sb', 'sc', (err, union) => {
assert.deepEqual(union.sort(), ['a', 'b', 'c', 'd', 'e'])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/sunionstore.spec.js
View File

@@ -1,23 +1,23 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'sunionstore\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'sunionstore\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('stores the result of a union', function (done) {
it('stores the result of a union', (done) => {
client.sadd('sa', 'a', helper.isNumber(1))
client.sadd('sa', 'b', helper.isNumber(1))
client.sadd('sa', 'c', helper.isNumber(1))
@@ -32,14 +32,14 @@ describe('The \'sunionstore\' method', function () {
client.sunionstore('foo', 'sa', 'sb', 'sc', helper.isNumber(5))
client.smembers('foo', function (err, members) {
client.smembers('foo', (err, members) => {
assert.strictEqual(members.length, 5)
assert.deepEqual(members.sort(), ['a', 'b', 'c', 'd', 'e'])
return done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

26
test/commands/ttl.spec.js
View File

@@ -1,33 +1,33 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'ttl\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'ttl\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('returns the current ttl on a key', function (done) {
it('returns the current ttl on a key', (done) => {
client.set(['ttl key', 'ttl val'], helper.isString('OK'))
client.expire(['ttl key', '100'], helper.isNumber(1))
client.ttl(['ttl key'], function (err, ttl) {
client.ttl(['ttl key'], (err, ttl) => {
assert(ttl >= 99)
assert(ttl <= 100)
done(err)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

32
test/commands/type.spec.js
View File

@@ -1,51 +1,51 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'type\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'type\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('reports string type', function (done) {
it('reports string type', (done) => {
client.set(['string key', 'should be a string'], helper.isString('OK'))
client.type(['string key'], helper.isString('string', done))
})
it('reports list type', function (done) {
it('reports list type', (done) => {
client.rpush(['list key', 'should be a list'], helper.isNumber(1))
client.type(['list key'], helper.isString('list', done))
})
it('reports set type', function (done) {
it('reports set type', (done) => {
client.sadd(['set key', 'should be a set'], helper.isNumber(1))
client.type(['set key'], helper.isString('set', done))
})
it('reports zset type', function (done) {
it('reports zset type', (done) => {
client.zadd('zset key', ['10.0', 'should be a zset'], helper.isNumber(1))
client.type(['zset key'], helper.isString('zset', done))
})
it('reports hash type', function (done) {
it('reports hash type', (done) => {
client.hset('hash key', 'hashtest', 'should be a hash', helper.isNumber(1))
client.type(['hash key'], helper.isString('hash', done))
})
it('reports none for null key', function (done) {
it('reports none for null key', (done) => {
client.type('not here yet', helper.isString('none', done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

32
test/commands/watch.spec.js
View File

@@ -1,44 +1,44 @@
'use strict'
var assert = require('assert')
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const assert = require('assert')
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'watch\' method', function () {
helper.allTests(function (ip, args) {
var watched = 'foobar'
describe('The \'watch\' method', () => {
helper.allTests((ip, args) => {
const watched = 'foobar'
describe('using ' + ip, function () {
var client
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('does not execute transaction if watched key was modified prior to execution', function (done) {
it('does not execute transaction if watched key was modified prior to execution', (done) => {
client.watch(watched)
client.incr(watched)
var multi = client.multi()
const multi = client.multi()
multi.incr(watched)
multi.exec(helper.isNull(done))
})
it('successfully modifies other keys independently of transaction', function (done) {
it('successfully modifies other keys independently of transaction', (done) => {
client.set('unwatched', 200)
client.set(watched, 0)
client.watch(watched)
client.incr(watched)
client.multi().incr(watched).exec(function (err, replies) {
client.multi().incr(watched).exec((err, replies) => {
assert.strictEqual(err, null)
assert.strictEqual(replies, null, 'Aborted transaction multi-bulk reply should be null.')

24
test/commands/zadd.spec.js
View File

@@ -1,18 +1,18 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var assert = require('assert')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const assert = require('assert')
const redis = config.redis
describe('The \'zadd\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'zadd\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
@@ -29,7 +29,7 @@ describe('The \'zadd\' method', function () {
client.zadd('infinity', ['inf', 'should be also be inf'], helper.isNumber(1))
client.zadd('infinity', -Infinity, 'should be negative inf', helper.isNumber(1))
client.zadd('infinity', [99999999999999999999999, 'should not be inf'], helper.isNumber(1))
client.zrange('infinity', 0, -1, 'WITHSCORES', function (err, res) {
client.zrange('infinity', 0, -1, 'WITHSCORES', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res[5], 'inf')
assert.strictEqual(res[1], '-inf')
@@ -38,7 +38,7 @@ describe('The \'zadd\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

38
test/commands/zscan.spec.js
View File

@@ -1,18 +1,18 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var assert = require('assert')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const assert = require('assert')
const redis = config.redis
describe('The \'zscan\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'zscan\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
@@ -20,18 +20,18 @@ describe('The \'zscan\' method', function () {
it('return values', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
helper.serverVersionAtLeast.call(this, client, [2, 8, 0])
var hash = {}
var set = []
var zset = ['zset:1']
for (var i = 0; i < 500; i++) {
hash['key_' + i] = 'value_' + i
set.push('member_' + i)
zset.push(i, 'zMember_' + i)
const hash = {}
const set = []
const zset = ['zset:1']
for (let i = 0; i < 500; i++) {
hash[`key_${i}`] = `value_${i}`
set.push(`member_${i}`)
zset.push(i, `zMember_${i}`)
}
client.hmset('hash:1', hash)
client.sadd('set:1', set)
client.zadd(zset)
client.zscan('zset:1', 0, 'MATCH', '*', 'COUNT', 500, function (err, res) {
client.zscan('zset:1', 0, 'MATCH', '*', 'COUNT', 500, (err, res) => {
assert(!err)
assert.strictEqual(res.length, 2)
assert.strictEqual(res[1].length, 1000)
@@ -39,7 +39,7 @@ describe('The \'zscan\' method', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

22
test/commands/zscore.spec.js
View File

@@ -1,27 +1,27 @@
'use strict'
var config = require('../lib/config')
var helper = require('../helper')
var redis = config.redis
const config = require('../lib/config')
const helper = require('../helper')
const redis = config.redis
describe('The \'zscore\' method', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client
describe('The \'zscore\' method', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.flushdb(done)
})
})
it('should return the score of member in the sorted set at key', function (done) {
it('should return the score of member in the sorted set at key', (done) => {
client.zadd('myzset', 1, 'one')
client.zscore('myzset', 'one', helper.isString('1', done))
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
})

60
test/conect.slave.spec.js
View File

@@ -1,36 +1,36 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var RedisProcess = require('./lib/redis-process')
var rp
var path = require('path')
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const RedisProcess = require('./lib/redis-process')
let rp
const path = require('path')
const redis = config.redis
// TODO: Fix redis process spawn on windows
if (process.platform !== 'win32') {
describe('master slave sync', function () {
var master = null
var slave = null
describe('master slave sync', () => {
let master = null
let slave = null
before(function (done) {
helper.stopRedis(function () {
before((done) => {
helper.stopRedis(() => {
helper.startRedis('./conf/password.conf', done)
})
})
before(function (done) {
before((done) => {
if (helper.redisProcess().spawnFailed()) return done()
master = redis.createClient({
password: 'porkchopsandwiches'
})
var multi = master.multi()
var i = 0
const multi = master.multi()
let i = 0
while (i < 1000) {
i++
// Write some data in the redis instance, so there's something to sync
multi.set('foo' + i, 'bar' + new Array(500).join(Math.random()))
multi.set(`foo${i}`, `bar${new Array(500).join(Math.random())}`)
}
multi.exec(done)
})
@@ -38,18 +38,18 @@ if (process.platform !== 'win32') {
it('sync process and no master should delay ready being emitted for slaves', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var port = 6381
var firstInfo
const port = 6381
let firstInfo
slave = redis.createClient({
port: port,
retryStrategy: function (options) {
port,
retryStrategy (options) {
// Try to reconnect in very small intervals to catch the master_link_status down before the sync completes
return 10
}
})
var tmp = slave.info.bind(slave)
var i = 0
const tmp = slave.info.bind(slave)
let i = 0
slave.info = function (err, res) {
i++
tmp(err, res)
@@ -58,38 +58,38 @@ if (process.platform !== 'win32') {
}
}
slave.on('connect', function () {
slave.on('connect', () => {
assert.strictEqual(i, 0)
})
var end = helper.callFuncAfter(done, 2)
const end = helper.callFuncAfter(done, 2)
slave.on('ready', function () {
assert.strictEqual(this.serverInfo.master_link_status, 'up')
assert.strictEqual(firstInfo.master_link_status, 'down')
assert(i > 1)
this.get('foo300', function (err, res) {
this.get('foo300', (err, res) => {
assert.strictEqual(res.substr(0, 3), 'bar')
end(err)
})
})
RedisProcess.start(function (err, _rp) {
RedisProcess.start((err, _rp) => {
rp = _rp
end(err)
}, path.resolve(__dirname, './conf/slave.conf'), port)
})
after(function (done) {
after((done) => {
if (helper.redisProcess().spawnFailed()) return done()
var end = helper.callFuncAfter(done, 3)
const end = helper.callFuncAfter(done, 3)
rp.stop(end)
slave.end(true)
master.flushdb(function (err) {
master.flushdb((err) => {
end(err)
master.end(true)
})
helper.stopRedis(function () {
helper.stopRedis(() => {
helper.startRedis('./conf/redis.conf', end)
})
})

290
test/connection.spec.js
View File

@@ -1,26 +1,26 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
var intercept = require('intercept-stdout')
var net = require('net')
var client
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
const intercept = require('intercept-stdout')
const net = require('net')
let client
describe('connection tests', function () {
beforeEach(function () {
describe('connection tests', () => {
beforeEach(() => {
client = null
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('unofficially support for a private stream', function () {
it('unofficially support for a private stream', () => {
// While using a private stream, reconnection and other features are not going to work properly.
// Besides that some functions also have to be monkey patched to be safe from errors in this case.
// Therefore this is not officially supported!
var socket = new net.Socket()
const socket = new net.Socket()
client = new redis.RedisClient({
prefix: 'test'
}, socket)
@@ -33,99 +33,92 @@ describe('connection tests', function () {
assert.strictEqual(client.stream.listeners('error').length, 1)
})
describe('quit on lost connections', function () {
it('calling quit while the connection is down should not end in reconnecting version a', function (done) {
var called = 0
describe('quit on lost connections', () => {
it('calling quit while the connection is down should not end in reconnecting version a', (done) => {
let called = 0
client = redis.createClient({
port: 9999,
retryStrategy: function (options) {
var bool = client.quit(function (err, res) {
retryStrategy (options) {
client.quit((err, res) => {
assert.strictEqual(res, 'OK')
assert.strictEqual(err, null)
assert.strictEqual(called++, -1)
setTimeout(done, 25)
})
assert.strictEqual(bool, false)
assert.strictEqual(called++, 0)
return 5
}
})
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'Stream connection ended and command aborted.')
called = -1
})
})
it('calling quit while the connection is down should not end in reconnecting version b', function (done) {
var called = false
it('calling quit while the connection is down should not end in reconnecting version b', (done) => {
let called = false
client = redis.createClient(9999)
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'Stream connection ended and command aborted.')
called = true
})
var bool = client.quit(function (err, res) {
client.quit((err, res) => {
assert.strictEqual(res, 'OK')
assert.strictEqual(err, null)
assert(called)
done()
})
assert.strictEqual(bool, false)
})
it('calling quit while the connection is down without offline queue should end the connection right away', function (done) {
var called = false
it('calling quit while the connection is down without offline queue should end the connection right away', (done) => {
let called = false
client = redis.createClient(9999, {
enableOfflineQueue: false
})
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'SET can\'t be processed. The connection is not yet established and the offline queue is deactivated.')
called = true
})
var bool = client.quit(function (err, res) {
client.quit((err, res) => {
assert.strictEqual(res, 'OK')
assert.strictEqual(err, null)
assert(called)
done()
})
// TODO: In v.3 the quit command would be fired right away, so bool should be true
assert.strictEqual(bool, false)
})
it('calling quit while connected without offline queue should end the connection when all commands have finished', function (done) {
var called = false
it('calling quit while connected without offline queue should end the connection when all commands have finished', (done) => {
let called = false
client = redis.createClient({
enableOfflineQueue: false
})
client.on('ready', function () {
client.set('foo', 'bar', function (err, res) {
client.on('ready', () => {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'OK')
called = true
})
var bool = client.quit(function (err, res) {
client.quit((err, res) => {
assert.strictEqual(res, 'OK')
assert.strictEqual(err, null)
assert(called)
done()
})
// TODO: In v.3 the quit command would be fired right away, so bool should be true
assert.strictEqual(bool, true)
})
})
it('do not quit before connected or a connection issue is detected', function (done) {
it('do not quit before connected or a connection issue is detected', (done) => {
client = redis.createClient()
client.set('foo', 'bar', helper.isString('OK'))
var bool = client.quit(done)
assert.strictEqual(bool, false)
client.quit(done)
})
it('quit "succeeds" even if the client connection is closed while doing so', function (done) {
it('quit "succeeds" even if the client connection is closed while doing so', (done) => {
client = redis.createClient()
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'OK')
client.quit(function (err, res) {
client.quit((err, res) => {
assert.strictEqual(res, 'OK')
done(err)
})
@@ -133,62 +126,61 @@ describe('connection tests', function () {
})
})
it('quit right away if connection drops while quit command is on the fly', function (done) {
it('quit right away if connection drops while quit command is on the fly', (done) => {
client = redis.createClient()
client.once('ready', function () {
client.once('ready', () => {
client.set('foo', 'bar', helper.isError())
var bool = client.quit(done)
assert.strictEqual(bool, true)
process.nextTick(function () {
client.quit(done)
process.nextTick(() => {
client.stream.destroy()
})
})
})
})
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
describe('on lost connection', function () {
it('end connection while retry is still ongoing', function (done) {
var connectTimeout = 1000 // in ms
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
describe('on lost connection', () => {
it('end connection while retry is still ongoing', (done) => {
const connectTimeout = 1000 // in ms
client = redis.createClient({
connectTimeout: connectTimeout
connectTimeout
})
client.once('ready', function () {
client.once('ready', () => {
helper.killConnection(client)
})
client.on('reconnecting', function (params) {
client.on('reconnecting', (params) => {
client.end(true)
assert.strictEqual(params.timesConnected, 1)
setTimeout(done, 5)
})
})
it.skip('can not connect with wrong host / port in the options object', function (done) {
var options = {
it.skip('can not connect with wrong host / port in the options object', (done) => {
const options = {
host: 'somewhere',
port: 6379,
family: ip,
retryStrategy: function () {}
retryStrategy () {}
}
client = redis.createClient(options)
assert.strictEqual(client.connectionOptions.family, ip === 'IPv6' ? 6 : 4)
assert.strictEqual(Object.keys(options).length, 4)
var end = helper.callFuncAfter(done, 2)
const end = helper.callFuncAfter(done, 2)
client.on('error', function (err) {
client.on('error', (err) => {
assert(/CONNECTION_BROKEN|ENOTFOUND|EAI_AGAIN/.test(err.code))
end()
})
})
it('emits error once if reconnecting after command has been executed but not yet returned without callback', function (done) {
it('emits error once if reconnecting after command has been executed but not yet returned without callback', (done) => {
client = redis.createClient.apply(null, args)
client.on('ready', function () {
client.set('foo', 'bar', function (err) {
client.on('ready', () => {
client.set('foo', 'bar', (err) => {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
done()
})
@@ -197,11 +189,11 @@ describe('connection tests', function () {
})
})
it('retryStrategy used to reconnect with individual error', function (done) {
it('retryStrategy used to reconnect with individual error', (done) => {
client = redis.createClient({
retryStrategy: function (options) {
retryStrategy (options) {
if (options.totalRetryTime > 150) {
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'Stream connection ended and command aborted.')
assert.strictEqual(err.origin.message, 'Connection timeout')
done()
@@ -215,11 +207,11 @@ describe('connection tests', function () {
})
})
it('retryStrategy used to reconnect', function (done) {
it('retryStrategy used to reconnect', (done) => {
client = redis.createClient({
retryStrategy: function (options) {
retryStrategy (options) {
if (options.totalRetryTime > 150) {
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'Stream connection ended and command aborted.')
assert.strictEqual(err.code, 'NR_CLOSED')
assert.strictEqual(err.origin.code, 'ECONNREFUSED')
@@ -233,22 +225,22 @@ describe('connection tests', function () {
})
})
it('retryStrategy used to reconnect with defaults', function (done) {
var unhookIntercept = intercept(function () {
it('retryStrategy used to reconnect with defaults', (done) => {
const unhookIntercept = intercept(() => {
return ''
})
redis.debugMode = true
client = redis.createClient({
retryStrategy: function (options) {
retryStrategy (options) {
client.set('foo', 'bar')
assert(redis.debugMode)
return null
}
})
setTimeout(function () {
setTimeout(() => {
client.stream.destroy()
}, 50)
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'NR_CLOSED')
assert.strictEqual(err.message, 'Stream connection ended and command aborted.')
unhookIntercept()
@@ -258,69 +250,69 @@ describe('connection tests', function () {
})
})
describe('when not connected', function () {
describe('when not connected', () => {
// TODO: Fix this test
it.skip('emit an error after the socket timeout exceeded the connectTimeout time', function (done) {
var connectTimeout = 500 // in ms
it.skip('emit an error after the socket timeout exceeded the connectTimeout time', (done) => {
const connectTimeout = 500 // in ms
client = redis.createClient({
// Auto detect ipv4 and use non routable ip to trigger the timeout
host: '10.255.255.1',
connectTimeout: connectTimeout
connectTimeout
})
process.nextTick(function () {
process.nextTick(() => {
assert.strictEqual(client.stream.listeners('timeout').length, 1)
})
assert.strictEqual(client.address, '10.255.255.1:6379')
assert.strictEqual(client.connectionOptions.family, 4)
client.on('reconnecting', function (params) {
client.on('reconnecting', (params) => {
throw new Error('No reconnect, since no connection was ever established')
})
var time = Date.now()
client.on('error', function (err) {
const time = Date.now()
client.on('error', (err) => {
if (err.code === 'ENETUNREACH') { // The test is run without a internet connection. Pretent it works
return done()
}
assert(/Redis connection in broken state: connection timeout.*?exceeded./.test(err.message), err.message)
// The code execution on windows is very slow at times
var add = process.platform !== 'win32' ? 15 : 200
var now = Date.now()
assert(now - time < connectTimeout + add, 'The real timeout time should be below ' + (connectTimeout + add) + 'ms but is: ' + (now - time))
const add = process.platform !== 'win32' ? 15 : 200
const now = Date.now()
assert(now - time < connectTimeout + add, `The real timeout time should be below ${connectTimeout + add}ms but is: ${now - time}`)
// Timers sometimes trigger early (e.g. 1ms to early)
assert(now - time >= connectTimeout - 5, 'The real timeout time should be above ' + connectTimeout + 'ms, but it is: ' + (now - time))
assert(now - time >= connectTimeout - 5, `The real timeout time should be above ${connectTimeout}ms, but it is: ${now - time}`)
done()
})
})
it('use the system socket timeout if the connectTimeout has not been provided', function (done) {
it('use the system socket timeout if the connectTimeout has not been provided', (done) => {
client = redis.createClient({
host: '2001:db8::ff00:42:8329' // auto detect ip v6
})
assert.strictEqual(client.address, '2001:db8::ff00:42:8329:6379')
assert.strictEqual(client.connectionOptions.family, 6)
process.nextTick(function () {
process.nextTick(() => {
assert.strictEqual(client.stream.listeners('timeout').length, 0)
done()
})
client.end(true)
})
it('clears the socket timeout after a connection has been established', function (done) {
it('clears the socket timeout after a connection has been established', (done) => {
client = redis.createClient({
connectTimeout: 1000
})
process.nextTick(function () {
process.nextTick(() => {
assert.strictEqual(client.stream._idleTimeout, 1000)
})
client.on('connect', function () {
client.on('connect', () => {
assert.strictEqual(client.stream._idleTimeout, -1)
assert.strictEqual(client.stream.listeners('timeout').length, 0)
client.on('ready', done)
})
})
it('connect with host and port provided in the options object', function (done) {
it('connect with host and port provided in the options object', (done) => {
client = redis.createClient({
host: 'localhost',
port: '6379',
@@ -339,114 +331,114 @@ describe('connection tests', function () {
connectTimeout: 1000
})
var end = helper.callFuncAfter(done, 2)
const end = helper.callFuncAfter(done, 2)
client.once('ready', end)
client.set('foo', 'bar', end)
})
it('connects correctly with args', function (done) {
it('connects correctly with args', (done) => {
client = redis.createClient.apply(null, args)
client.on('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.removeListener('error', done)
client.get('recon 1', done)
})
})
it('connects correctly with default values', function (done) {
it('connects correctly with default values', (done) => {
client = redis.createClient()
client.on('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.removeListener('error', done)
client.get('recon 1', done)
})
})
it('connects with a port only', function (done) {
it('connects with a port only', (done) => {
client = redis.createClient(6379)
assert.strictEqual(client.connectionOptions.family, 4)
client.on('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.removeListener('error', done)
client.get('recon 1', done)
})
})
it('connects correctly to localhost', function (done) {
it('connects correctly to localhost', (done) => {
client = redis.createClient(null, null)
client.on('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.removeListener('error', done)
client.get('recon 1', done)
})
})
it('connects correctly to the provided host with the port set to null', function (done) {
it('connects correctly to the provided host with the port set to null', (done) => {
client = redis.createClient(null, 'localhost')
client.on('error', done)
assert.strictEqual(client.address, 'localhost:6379')
client.once('ready', function () {
client.once('ready', () => {
client.set('foo', 'bar')
client.get('foo', function (err, res) {
client.get('foo', (err, res) => {
assert.strictEqual(res, 'bar')
done(err)
})
})
})
it('connects correctly to localhost and no ready check', function (done) {
it('connects correctly to localhost and no ready check', (done) => {
client = redis.createClient(undefined, undefined, {
noReadyCheck: true
})
client.on('error', done)
client.once('ready', function () {
client.once('ready', () => {
client.set('foo', 'bar')
client.get('foo', function (err, res) {
client.get('foo', (err, res) => {
assert.strictEqual(res, 'bar')
done(err)
})
})
})
it('connects correctly to the provided host with the port set to undefined', function (done) {
it('connects correctly to the provided host with the port set to undefined', (done) => {
client = redis.createClient(undefined, 'localhost', {
noReadyCheck: true
})
client.on('error', done)
assert.strictEqual(client.address, 'localhost:6379')
client.once('ready', function () {
client.once('ready', () => {
client.set('foo', 'bar')
client.get('foo', function (err, res) {
client.get('foo', (err, res) => {
assert.strictEqual(res, 'bar')
done(err)
})
})
})
it('connects correctly even if the info command is not present on the redis server', function (done) {
it('connects correctly even if the info command is not present on the redis server', (done) => {
client = redis.createClient.apply(null, args)
client.info = function (cb) {
// Mock the result
cb(new Error('ERR unknown command \'info\''))
}
client.once('ready', function () {
client.once('ready', () => {
assert.strictEqual(Object.keys(client.serverInfo).length, 0)
done()
})
})
it('fake the stream to mock redis', function () {
it('fake the stream to mock redis', () => {
// This is needed for libraries that want to mock the stream like fakeredis
var temp = redis.RedisClient.prototype.createStream
var createStreamString = String(temp)
const temp = redis.RedisClient.prototype.createStream
const createStreamString = String(temp)
redis.RedisClient.prototype.createStream = function () {
this.connected = true
this.ready = true
@@ -462,23 +454,23 @@ describe('connection tests', function () {
})
if (ip === 'IPv4') {
it('allows connecting with the redis url to the default host and port, select db 3 and warn about duplicate db option', function (done) {
it('allows connecting with the redis url to the default host and port, select db 3 and warn about duplicate db option', (done) => {
client = redis.createClient('redis:///3?db=3')
assert.strictEqual(client.selectedDb, '3')
client.on('ready', done)
})
it('allows connecting with the redis url and the default port and auth provided even though it is not required', function (done) {
client = redis.createClient('redis://:porkchopsandwiches@' + config.HOST[ip] + '/')
var end = helper.callFuncAfter(done, 2)
client.on('warning', function (msg) {
it('allows connecting with the redis url and the default port and auth provided even though it is not required', (done) => {
client = redis.createClient(`redis://:porkchopsandwiches@${config.HOST[ip]}/`)
const end = helper.callFuncAfter(done, 2)
client.on('warning', (msg) => {
assert.strictEqual(msg, 'Warning: Redis server does not require a password, but a password was supplied.')
end()
})
client.on('ready', end)
})
it('allows connecting with the redis url as first parameter and the options as second parameter', function (done) {
it('allows connecting with the redis url as first parameter and the options as second parameter', (done) => {
client = redis.createClient('//127.0.0.1', {
connectTimeout: 1000
})
@@ -486,9 +478,9 @@ describe('connection tests', function () {
client.on('ready', done)
})
it('allows connecting with the redis url in the options object and works with protocols other than the redis protocol (e.g. http)', function (done) {
it('allows connecting with the redis url in the options object and works with protocols other than the redis protocol (e.g. http)', (done) => {
client = redis.createClient({
url: 'http://foo:porkchopsandwiches@' + config.HOST[ip] + '/3'
url: `http://foo:porkchopsandwiches@${config.HOST[ip]}/3`
})
assert.strictEqual(client.authPass, 'porkchopsandwiches')
assert.strictEqual(+client.selectedDb, 3)
@@ -497,32 +489,32 @@ describe('connection tests', function () {
client.on('ready', done)
})
it('allows connecting with the redis url and no auth and options as second parameter', function (done) {
var options = {
it('allows connecting with the redis url and no auth and options as second parameter', (done) => {
const options = {
detectBuffers: false
}
client = redis.createClient('redis://' + config.HOST[ip] + ':' + config.PORT, options)
client = redis.createClient(`redis://${config.HOST[ip]}:${config.PORT}`, options)
assert.strictEqual(Object.keys(options).length, 1)
client.on('ready', done)
})
it('allows connecting with the redis url and no auth and options as third parameter', function (done) {
client = redis.createClient('redis://' + config.HOST[ip] + ':' + config.PORT, null, {
it('allows connecting with the redis url and no auth and options as third parameter', (done) => {
client = redis.createClient(`redis://${config.HOST[ip]}:${config.PORT}`, null, {
detectBuffers: false
})
client.on('ready', done)
})
}
it('redis still loading <= 500', function (done) {
it('redis still loading <= 500', (done) => {
client = redis.createClient.apply(null, args)
var tmp = client.info.bind(client)
var end = helper.callFuncAfter(done, 3)
var delayed = false
var time
const tmp = client.info.bind(client)
const end = helper.callFuncAfter(done, 3)
let delayed = false
let time
// Mock original function and pretent redis is still loading
client.info = function (cb) {
tmp(function (err, res) {
tmp((err, res) => {
if (!delayed) {
assert(!err)
client.serverInfo.loading = 1
@@ -534,25 +526,25 @@ describe('connection tests', function () {
cb(err, res)
})
}
client.on('ready', function () {
var rest = Date.now() - time
assert(rest >= 495, 'Rest should be equal or above 500 ms but is: ' + rest) // setTimeout might trigger early
client.on('ready', () => {
const rest = Date.now() - time
assert(rest >= 495, `Rest should be equal or above 500 ms but is: ${rest}`) // setTimeout might trigger early
// Be on the safe side and accept 200ms above the original value
assert(rest - 250 < 500, 'Rest - 250 should be below 500 ms but is: ' + (rest - 250))
assert(rest - 250 < 500, `Rest - 250 should be below 500 ms but is: ${rest - 250}`)
assert(delayed)
end()
})
})
it('redis still loading > 1000ms', function (done) {
it('redis still loading > 1000ms', (done) => {
client = redis.createClient.apply(null, args)
var tmp = client.info.bind(client)
var end = helper.callFuncAfter(done, 3)
var delayed = false
var time
const tmp = client.info.bind(client)
const end = helper.callFuncAfter(done, 3)
let delayed = false
let time
// Mock original function and pretent redis is still loading
client.info = function (cb) {
tmp(function (err, res) {
tmp((err, res) => {
if (!delayed) {
assert(!err)
// Try reconnecting after one second even if redis tells us the time needed is above one second
@@ -565,11 +557,11 @@ describe('connection tests', function () {
cb(err, res)
})
}
client.on('ready', function () {
var rest = Date.now() - time
assert(rest >= 998, '`rest` should be equal or above 1000 ms but is: ' + rest) // setTimeout might trigger early
client.on('ready', () => {
const rest = Date.now() - time
assert(rest >= 998, `\`rest\` should be equal or above 1000 ms but is: ${rest}`) // setTimeout might trigger early
// Be on the safe side and accept 200ms above the original value
assert(rest - 250 < 1000, '`rest` - 250 should be below 1000 ms but is: ' + (rest - 250))
assert(rest - 250 < 1000, `\`rest\` - 250 should be below 1000 ms but is: ${rest - 250}`)
assert(delayed)
end()
})

34
test/custom_errors.spec.js
View File

@@ -1,12 +1,12 @@
'use strict'
var assert = require('assert')
var errors = require('../lib/customErrors')
const assert = require('assert')
const errors = require('../lib/customErrors')
describe('errors', function () {
describe('AbortError', function () {
it('should inherit from Error', function () {
var e = new errors.AbortError({})
describe('errors', () => {
describe('AbortError', () => {
it('should inherit from Error', () => {
const e = new errors.AbortError({})
assert.strictEqual(e.message, '')
assert.strictEqual(e.name, 'AbortError')
assert.strictEqual(Object.keys(e).length, 0)
@@ -14,8 +14,8 @@ describe('errors', function () {
assert(e instanceof errors.AbortError)
})
it('should list options properties but not name and message', function () {
var e = new errors.AbortError({
it('should list options properties but not name and message', () => {
const e = new errors.AbortError({
name: 'weird',
message: 'hello world',
property: true
@@ -30,8 +30,8 @@ describe('errors', function () {
assert.strictEqual(e.name, 'AbortError')
})
it('should change name and message', function () {
var e = new errors.AbortError({
it('should change name and message', () => {
const e = new errors.AbortError({
message: 'hello world',
property: true
})
@@ -44,9 +44,9 @@ describe('errors', function () {
})
})
describe('AggregateError', function () {
it('should inherit from Error and AbortError', function () {
var e = new errors.AggregateError({})
describe('AggregateError', () => {
it('should inherit from Error and AbortError', () => {
const e = new errors.AggregateError({})
assert.strictEqual(e.message, '')
assert.strictEqual(e.name, 'AggregateError')
assert.strictEqual(Object.keys(e).length, 0)
@@ -55,8 +55,8 @@ describe('errors', function () {
assert(e instanceof errors.AbortError)
})
it('should list options properties but not name and message', function () {
var e = new errors.AggregateError({
it('should list options properties but not name and message', () => {
const e = new errors.AggregateError({
name: 'weird',
message: 'hello world',
property: true
@@ -72,8 +72,8 @@ describe('errors', function () {
assert.strictEqual(e.name, 'AggregateError')
})
it('should change name and message', function () {
var e = new errors.AggregateError({
it('should change name and message', () => {
const e = new errors.AggregateError({
message: 'hello world',
property: true
})

120
test/detect_buffers.spec.js
View File

@@ -1,22 +1,22 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
describe('detectBuffers', function () {
var client
var args = config.configureClient('localhost', {
describe('detectBuffers', () => {
let client
const args = config.configureClient('localhost', {
detectBuffers: true
})
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('error', done)
client.once('connect', function () {
client.flushdb(function (err) {
client.once('connect', () => {
client.flushdb((err) => {
client.hmset('hash key 2', 'key 1', 'val 1', 'key 2', 'val 2')
client.set('string key 1', 'string value')
return done(err)
@@ -24,34 +24,34 @@ describe('detectBuffers', function () {
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
describe('get', function () {
describe('first argument is a string', function () {
it('returns a string', function (done) {
describe('get', () => {
describe('first argument is a string', () => {
it('returns a string', (done) => {
client.get('string key 1', helper.isString('string value', done))
})
it('returns a string when executed as part of transaction', function (done) {
client.multi().get('string key 1').exec(function (err, res) {
it('returns a string when executed as part of transaction', (done) => {
client.multi().get('string key 1').exec((err, res) => {
helper.isString('string value', done)(err, res[0])
})
})
})
describe('first argument is a buffer', function () {
it('returns a buffer', function (done) {
client.get(Buffer.from('string key 1'), function (err, reply) {
describe('first argument is a buffer', () => {
it('returns a buffer', (done) => {
client.get(Buffer.from('string key 1'), (err, reply) => {
assert.strictEqual(true, Buffer.isBuffer(reply))
assert.strictEqual('<Buffer 73 74 72 69 6e 67 20 76 61 6c 75 65>', reply.inspect())
return done(err)
})
})
it('returns a bufffer when executed as part of transaction', function (done) {
client.multi().get(Buffer.from('string key 1')).exec(function (err, reply) {
it('returns a bufffer when executed as part of transaction', (done) => {
client.multi().get(Buffer.from('string key 1')).exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual(true, Buffer.isBuffer(reply[0]))
assert.strictEqual('<Buffer 73 74 72 69 6e 67 20 76 61 6c 75 65>', reply[0].inspect())
@@ -61,14 +61,14 @@ describe('detectBuffers', function () {
})
})
describe('multi.hget', function () {
it('can interleave string and buffer results', function (done) {
describe('multi.hget', () => {
it('can interleave string and buffer results', (done) => {
client.multi()
.hget('hash key 2', 'key 1')
.hget(Buffer.from('hash key 2'), 'key 1')
.hget('hash key 2', Buffer.from('key 2'))
.hget('hash key 2', 'key 2')
.exec(function (err, reply) {
.exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(4, reply.length)
assert.strictEqual('val 1', reply[0])
@@ -82,14 +82,14 @@ describe('detectBuffers', function () {
})
})
describe('batch.hget', function () {
it('can interleave string and buffer results', function (done) {
describe('batch.hget', () => {
it('can interleave string and buffer results', (done) => {
client.batch()
.hget('hash key 2', 'key 1')
.hget(Buffer.from('hash key 2'), 'key 1')
.hget('hash key 2', Buffer.from('key 2'))
.hget('hash key 2', 'key 2')
.exec(function (err, reply) {
.exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(4, reply.length)
assert.strictEqual('val 1', reply[0])
@@ -103,10 +103,10 @@ describe('detectBuffers', function () {
})
})
describe('hmget', function () {
describe('first argument is a string', function () {
it('returns strings for keys requested', function (done) {
client.hmget('hash key 2', 'key 1', 'key 2', function (err, reply) {
describe('hmget', () => {
describe('first argument is a string', () => {
it('returns strings for keys requested', (done) => {
client.hmget('hash key 2', 'key 1', 'key 2', (err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(2, reply.length)
assert.strictEqual('val 1', reply[0])
@@ -115,8 +115,8 @@ describe('detectBuffers', function () {
})
})
it('returns strings for keys requested in transaction', function (done) {
client.multi().hmget('hash key 2', 'key 1', 'key 2').exec(function (err, reply) {
it('returns strings for keys requested in transaction', (done) => {
client.multi().hmget('hash key 2', 'key 1', 'key 2').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -126,8 +126,8 @@ describe('detectBuffers', function () {
})
})
it('handles array of strings with undefined values (repro #344)', function (done) {
client.hmget('hash key 2', 'key 3', 'key 4', function (err, reply) {
it('handles array of strings with undefined values (repro #344)', (done) => {
client.hmget('hash key 2', 'key 3', 'key 4', (err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(2, reply.length)
assert.strictEqual(null, reply[0])
@@ -136,8 +136,8 @@ describe('detectBuffers', function () {
})
})
it('handles array of strings with undefined values in transaction (repro #344)', function (done) {
client.multi().hmget('hash key 2', 'key 3', 'key 4').exec(function (err, reply) {
it('handles array of strings with undefined values in transaction (repro #344)', (done) => {
client.multi().hmget('hash key 2', 'key 3', 'key 4').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -148,9 +148,9 @@ describe('detectBuffers', function () {
})
})
describe('first argument is a buffer', function () {
it('returns buffers for keys requested', function (done) {
client.hmget(Buffer.from('hash key 2'), 'key 1', 'key 2', function (err, reply) {
describe('first argument is a buffer', () => {
it('returns buffers for keys requested', (done) => {
client.hmget(Buffer.from('hash key 2'), 'key 1', 'key 2', (err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(2, reply.length)
assert.strictEqual(true, Buffer.isBuffer(reply[0]))
@@ -161,8 +161,8 @@ describe('detectBuffers', function () {
})
})
it('returns buffers for keys requested in transaction', function (done) {
client.multi().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec(function (err, reply) {
it('returns buffers for keys requested in transaction', (done) => {
client.multi().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -174,8 +174,8 @@ describe('detectBuffers', function () {
})
})
it('returns buffers for keys requested in .batch', function (done) {
client.batch().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec(function (err, reply) {
it('returns buffers for keys requested in .batch', (done) => {
client.batch().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -189,10 +189,10 @@ describe('detectBuffers', function () {
})
})
describe('hgetall', function (done) {
describe('first argument is a string', function () {
it('returns string values', function (done) {
client.hgetall('hash key 2', function (err, reply) {
describe('hgetall', (done) => {
describe('first argument is a string', () => {
it('returns string values', (done) => {
client.hgetall('hash key 2', (err, reply) => {
assert.strictEqual('object', typeof reply)
assert.strictEqual(2, Object.keys(reply).length)
assert.strictEqual('val 1', reply['key 1'])
@@ -201,8 +201,8 @@ describe('detectBuffers', function () {
})
})
it('returns string values when executed in transaction', function (done) {
client.multi().hgetall('hash key 2').exec(function (err, reply) {
it('returns string values when executed in transaction', (done) => {
client.multi().hgetall('hash key 2').exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -212,8 +212,8 @@ describe('detectBuffers', function () {
})
})
it('returns string values when executed in .batch', function (done) {
client.batch().hgetall('hash key 2').exec(function (err, reply) {
it('returns string values when executed in .batch', (done) => {
client.batch().hgetall('hash key 2').exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -224,9 +224,9 @@ describe('detectBuffers', function () {
})
})
describe('first argument is a buffer', function () {
it('returns buffer values', function (done) {
client.hgetall(Buffer.from('hash key 2'), function (err, reply) {
describe('first argument is a buffer', () => {
it('returns buffer values', (done) => {
client.hgetall(Buffer.from('hash key 2'), (err, reply) => {
assert.strictEqual(null, err)
assert.strictEqual('object', typeof reply)
assert.strictEqual(2, Object.keys(reply).length)
@@ -238,8 +238,8 @@ describe('detectBuffers', function () {
})
})
it('returns buffer values when executed in transaction', function (done) {
client.multi().hgetall(Buffer.from('hash key 2')).exec(function (err, reply) {
it('returns buffer values when executed in transaction', (done) => {
client.multi().hgetall(Buffer.from('hash key 2')).exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -251,8 +251,8 @@ describe('detectBuffers', function () {
})
})
it('returns buffer values when executed in .batch', function (done) {
client.batch().hgetall(Buffer.from('hash key 2')).exec(function (err, reply) {
it('returns buffer values when executed in .batch', (done) => {
client.batch().hgetall(Buffer.from('hash key 2')).exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)

32
test/good_traces.spec.js
View File

@@ -1,44 +1,44 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var fork = require('child_process').fork
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const fork = require('child_process').fork
const redis = config.redis
describe('stack traces', function () {
it('should return good traces with NODE_ENV=development set', function (done) {
var external = fork('./test/lib/good-traces.js', {
describe('stack traces', () => {
it('should return good traces with NODE_ENV=development set', (done) => {
const external = fork('./test/lib/good-traces.js', {
env: {
NODE_ENV: 'development'
}
})
var id = setTimeout(function () {
const id = setTimeout(() => {
external.kill()
done(new Error('Timeout'))
}, 6000)
external.on('close', function (code) {
external.on('close', (code) => {
clearTimeout(id)
assert.strictEqual(code, 0)
done()
})
})
it('should return good traces with NODE_DEBUG=redis env set', function (done) {
var external = fork('./test/lib/good-traces.js', {
it('should return good traces with NODE_DEBUG=redis env set', (done) => {
const external = fork('./test/lib/good-traces.js', {
env: {
NODE_DEBUG: 'redis'
},
silent: true
})
var id = setTimeout(function () {
const id = setTimeout(() => {
external.kill()
done(new Error('Timeout'))
}, 6000)
external.on('close', function (code) {
external.on('close', (code) => {
clearTimeout(id)
assert.strictEqual(code, 0)
done()
@@ -46,11 +46,11 @@ describe('stack traces', function () {
})
// This is always going to return good stack traces
it('should always return good stack traces for rejected offline commands', function (done) {
var client = redis.createClient({
it('should always return good stack traces for rejected offline commands', (done) => {
const client = redis.createClient({
enableOfflineQueue: false
})
client.set('foo', function (err, res) {
client.set('foo', (err, res) => {
assert(/good_traces.spec.js/.test(err.stack))
client.quit(done)
})

128
test/helper.js
View File

@@ -1,15 +1,15 @@
'use strict'
var assert = require('assert')
var path = require('path')
var config = require('./lib/config')
var RedisProcess = require('./lib/redis-process')
var StunnelProcess = require('./lib/stunnel-process')
var rp
var stunnelProcess
const assert = require('assert')
const path = require('path')
const config = require('./lib/config')
const RedisProcess = require('./lib/redis-process')
const StunnelProcess = require('./lib/stunnel-process')
let rp
let stunnelProcess
function startRedis (conf, done, port) {
RedisProcess.start(function (err, _rp) {
RedisProcess.start((err, _rp) => {
rp = _rp
return done(err)
}, path.resolve(__dirname, conf), port)
@@ -20,11 +20,11 @@ function startRedis (conf, done, port) {
if (!process.env.REDIS_TESTS_STARTED) {
process.env.REDIS_TESTS_STARTED = true
before(function (done) {
before((done) => {
startRedis('./conf/redis.conf', done)
})
after(function (done) {
after((done) => {
if (rp) rp.stop(done)
})
}
@@ -49,120 +49,120 @@ function toString (res) {
}
module.exports = {
redisProcess: function () {
redisProcess () {
return rp
},
stopRedis: function (done) {
stopRedis (done) {
rp.stop(done)
},
startRedis: startRedis,
stopStunnel: function (done) {
startRedis,
stopStunnel (done) {
if (stunnelProcess) {
StunnelProcess.stop(stunnelProcess, done)
} else {
done()
}
},
startStunnel: function (done) {
StunnelProcess.start(function (err, _stunnelProcess) {
startStunnel (done) {
StunnelProcess.start((err, _stunnelProcess) => {
stunnelProcess = _stunnelProcess
return done(err)
}, path.resolve(__dirname, './conf'))
},
isNumber: function (expected, done) {
isNumber (expected, done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected ' + expected + ', got error: ' + err)
assert.strictEqual(err, null, `expected ${expected}, got error: ${err}`)
results = arrayHelper(results)
assert.strictEqual(results, expected, expected + ' !== ' + results)
assert.strictEqual(typeof results, 'number', 'expected a number, got ' + typeof results)
assert.strictEqual(results, expected, `${expected } !== ${results}`)
assert.strictEqual(typeof results, 'number', `expected a number, got ${typeof results}`)
if (done) done()
}
},
isString: function (str, done) {
str = '' + str // Make sure it's a string
isString (str, done) {
str = `${str}` // Make sure it's a string
return function (err, results) {
assert.strictEqual(err, null, 'expected string \'' + str + '\', got error: ' + err)
assert.strictEqual(err, null, `expected string '${str}', got error: ${err}`)
results = arrayHelper(results)
results = toString(results)
assert.strictEqual(results, str, str + ' does not match ' + results)
assert.strictEqual(results, str, `${str } does not match ${results}`)
if (done) done()
}
},
isNull: function (done) {
isNull (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected null, got error: ' + err)
assert.strictEqual(err, null, `expected null, got error: ${err}`)
results = arrayHelper(results)
assert.strictEqual(results, null, results + ' is not null')
assert.strictEqual(results, null, `${results } is not null`)
if (done) done()
}
},
isUndefined: function (done) {
isUndefined (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected null, got error: ' + err)
assert.strictEqual(err, null, `expected null, got error: ${err}`)
results = arrayHelper(results)
assert.strictEqual(results, undefined, results + ' is not undefined')
assert.strictEqual(results, undefined, `${results } is not undefined`)
if (done) done()
}
},
isError: function (done) {
isError (done) {
return function (err, results) {
assert(err instanceof Error, 'err is not instance of \'Error\', but an error is expected here.')
if (done) done()
}
},
isNotError: function (done) {
isNotError (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected success, got an error: ' + err)
assert.strictEqual(err, null, `expected success, got an error: ${err}`)
if (done) done()
}
},
isDeepEqual: function (args, done) {
isDeepEqual (args, done) {
return function (err, res) {
assert.strictEqual(err, null, 'expected null, got error: ' + err)
assert.strictEqual(err, null, `expected null, got error: ${err}`)
res = toString(res)
assert.deepStrictEqual(res, args)
if (done) done()
}
},
isType: {
number: function (done) {
number (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected any number, got error: ' + err)
assert.strictEqual(typeof results, 'number', results + ' is not a number')
assert.strictEqual(err, null, `expected any number, got error: ${err}`)
assert.strictEqual(typeof results, 'number', `${results } is not a number`)
if (done) done()
}
},
string: function (done) {
string (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected any string, got error: ' + err)
assert.strictEqual(typeof results, 'string', results + ' is not a string')
assert.strictEqual(err, null, `expected any string, got error: ${err}`)
assert.strictEqual(typeof results, 'string', `${results } is not a string`)
if (done) done()
}
},
positiveNumber: function (done) {
positiveNumber (done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected positive number, got error: ' + err)
assert(results > 0, results + ' is not a positive number')
assert.strictEqual(err, null, `expected positive number, got error: ${err}`)
assert(results > 0, `${results } is not a positive number`)
if (done) done()
}
}
},
match: function (pattern, done) {
match (pattern, done) {
return function (err, results) {
assert.strictEqual(err, null, 'expected ' + pattern.toString() + ', got error: ' + err)
assert.strictEqual(err, null, `expected ${pattern.toString()}, got error: ${err}`)
results = arrayHelper(results)
assert(pattern.test(results), 'expected string \'' + results + '\' to match ' + pattern.toString())
assert(pattern.test(results), `expected string '${results}' to match ${pattern.toString()}`)
if (done) done()
}
},
serverVersionAtLeast: function (connection, desiredVersion) {
serverVersionAtLeast (connection, desiredVersion) {
// Wait until a connection has established (otherwise a timeout is going to be triggered at some point)
if (Object.keys(connection.serverInfo).length === 0) {
throw new Error('Version check not possible as the client is not yet ready or did not expose the version')
}
// Return true if the server version >= desiredVersion
var version = connection.serverInfo.versions
for (var i = 0; i < 3; i++) {
const version = connection.serverInfo.versions
for (let i = 0; i < 3; i++) {
if (version[i] > desiredVersion[i]) {
return true
}
@@ -173,30 +173,30 @@ module.exports = {
}
return true
},
allTests: function (opts, cb) {
allTests (opts, cb) {
if (!cb) {
cb = opts
opts = {}
}
var protocols = ['IPv4']
const protocols = ['IPv4']
if (process.platform !== 'win32') {
protocols.push('IPv6', '/tmp/redis.sock')
}
var options = [{
const options = [{
detectBuffers: true
}, {
detectBuffers: false
}]
options.forEach(function (options) {
var strOptions = ''
var key
options.forEach((options) => {
let strOptions = ''
let key
for (key in options) {
if (options.hasOwnProperty(key)) {
strOptions += key + ': ' + options[key] + '; '
strOptions += `${key }: ${options[key]}; `
}
}
describe('using options: ' + strOptions, function () {
protocols.forEach(function (ip, i) {
describe(`using options: ${strOptions}`, () => {
protocols.forEach((ip, i) => {
if (i !== 0 && !opts.allConnections) {
return
}
@@ -205,13 +205,13 @@ module.exports = {
})
})
},
removeMochaListener: function () {
var mochaListener = process.listeners('uncaughtException').pop()
removeMochaListener () {
const mochaListener = process.listeners('uncaughtException').pop()
process.removeListener('uncaughtException', mochaListener)
return mochaListener
},
callFuncAfter: function (func, max) {
var i = 0
callFuncAfter (func, max) {
let i = 0
return function (err) {
if (err) {
throw err
@@ -224,7 +224,7 @@ module.exports = {
return false
}
},
killConnection: function (client) {
killConnection (client) {
// Change the connection option to a non existing one and destroy the stream
client.connectionOptions = {
port: 65535,

12
test/lib/config.js
View File

@@ -2,22 +2,22 @@
// helpers for configuring a redis client in
// its various modes, ipV6, ipV4, socket.
var redis = require('../../index')
var bluebird = require('bluebird')
const redis = require('../../index')
const bluebird = require('bluebird')
// Promisify everything
bluebird.promisifyAll(redis.RedisClient.prototype)
bluebird.promisifyAll(redis.Multi.prototype)
var config = {
redis: redis,
const config = {
redis,
PORT: 6379,
HOST: {
IPv4: '127.0.0.1',
IPv6: '::1'
},
configureClient: function (ip, opts) {
var args = []
configureClient (ip, opts) {
const args = []
// Do not manipulate the opts => copy them each time
opts = opts ? JSON.parse(JSON.stringify(opts)) : {}

14
test/lib/good-traces.js
View File

@@ -1,20 +1,20 @@
// Spawned by the goodStacks.spec.js tests
'use strict'
var assert = require('assert')
var redis = require('../../index')
var client = redis.createClient()
const assert = require('assert')
const redis = require('../../index')
const client = redis.createClient()
// Both error cases would normally return bad stack traces
client.set('foo', function (err, res) {
client.set('foo', (err, res) => {
assert(/good-traces.js:9:8/.test(err.stack))
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert(/good-traces.js:11:10/.test(err.stack))
client.quit(function () {
client.quit(() => {
process.exit(0)
})
})
process.nextTick(function () {
process.nextTick(() => {
client.stream.destroy()
})
})

56
test/lib/redis-process.js
View File

@@ -1,82 +1,82 @@
'use strict'
// helper to start and stop the redis process.
var config = require('./config')
var fs = require('fs')
var path = require('path')
var spawn = require('win-spawn')
var tcpPortUsed = require('tcp-port-used')
var bluebird = require('bluebird')
const config = require('./config')
const fs = require('fs')
const path = require('path')
const spawn = require('win-spawn')
const tcpPortUsed = require('tcp-port-used')
const bluebird = require('bluebird')
// wait for redis to be listening in
// all three modes (ipv4, ipv6, socket).
function waitForRedis (available, cb, port) {
if (process.platform === 'win32') return cb()
var time = Date.now()
var running = false
var socket = '/tmp/redis.sock'
const time = Date.now()
let running = false
let socket = '/tmp/redis.sock'
if (port) {
// We have to distinguish the redis sockets if we have more than a single redis instance running
socket = '/tmp/redis' + port + '.sock'
socket = `/tmp/redis${port}.sock`
}
port = port || config.PORT
var id = setInterval(function () {
const id = setInterval(() => {
if (running) return
running = true
bluebird.join(
tcpPortUsed.check(port, '127.0.0.1'),
tcpPortUsed.check(port, '::1'),
function (ipV4, ipV6) {
(ipV4, ipV6) => {
if (ipV6 === available && ipV4 === available) {
if (fs.existsSync(socket) === available) {
clearInterval(id)
return cb()
}
// The same message applies for can't stop but we ignore that case
throw new Error('Port ' + port + ' is already in use. Tests can\'t start.\n')
throw new Error(`Port ${port} is already in use. Tests can't start.\n`)
}
if (Date.now() - time > 6000) {
throw new Error('Redis could not start on port ' + (port || config.PORT) + '\n')
throw new Error(`Redis could not start on port ${port || config.PORT}\n`)
}
running = false
}).catch(function (err) {
console.error('\x1b[31m' + err.stack + '\x1b[0m\n')
}).catch((err) => {
console.error(`\x1b[31m${err.stack}\x1b[0m\n`)
process.exit(1)
})
}, 100)
}
module.exports = {
start: function (done, conf, port) {
var spawnFailed = false
start (done, conf, port) {
let spawnFailed = false
// spawn redis with our testing configuration.
var confFile = conf || path.resolve(__dirname, '../conf/redis.conf')
var rp = spawn('redis-server', [confFile], {})
const confFile = conf || path.resolve(__dirname, '../conf/redis.conf')
const rp = spawn('redis-server', [confFile], {})
// capture a failure booting redis, and give
// the user running the test some directions.
rp.once('exit', function (code) {
rp.once('exit', (code) => {
if (code !== 0) spawnFailed = true
})
// wait for redis to become available, by
// checking the port we bind on.
waitForRedis(true, function () {
waitForRedis(true, () => {
// return an object that can be used in
// an after() block to shutdown redis.
return done(null, {
spawnFailed: function () {
spawnFailed () {
return spawnFailed
},
stop: function (done) {
stop (done) {
if (spawnFailed) return done()
rp.once('exit', function (code) {
var error = null
rp.once('exit', (code) => {
let error = null
if (code !== null && code !== 0) {
error = new Error('Redis shutdown failed with code ' + code)
error = new Error(`Redis shutdown failed with code ${code}`)
}
waitForRedis(false, function () {
waitForRedis(false, () => {
return done(error)
}, port)
})

34
test/lib/stunnel-process.js
View File

@@ -1,14 +1,14 @@
'use strict'
// helper to start and stop the stunnel process.
var spawn = require('child_process').spawn
var EventEmitter = require('events')
var fs = require('fs')
var path = require('path')
var util = require('util')
const spawn = require('child_process').spawn
const EventEmitter = require('events')
const fs = require('fs')
const path = require('path')
const util = require('util')
function once (cb) {
var called = false
let called = false
return function () {
if (called) return
called = true
@@ -20,29 +20,29 @@ function StunnelProcess (confDir) {
EventEmitter.call(this)
// set up an stunnel to redis; edit the conf file to include required absolute paths
var confFile = path.resolve(confDir, 'stunnel.conf')
var confText = fs.readFileSync(confFile + '.template').toString().replace(/__dirname,/g, confDir)
const confFile = path.resolve(confDir, 'stunnel.conf')
const confText = fs.readFileSync(`${confFile }.template`).toString().replace(/__dirname,/g, confDir)
fs.writeFileSync(confFile, confText)
var stunnel = this.stunnel = spawn('stunnel', [confFile])
const stunnel = this.stunnel = spawn('stunnel', [confFile])
// handle child process events, and failure to set up tunnel
var self = this
this.timer = setTimeout(function () {
const self = this
this.timer = setTimeout(() => {
self.emit('error', new Error('Timeout waiting for stunnel to start'))
}, 8000)
stunnel.on('error', function (err) {
stunnel.on('error', (err) => {
self.clear()
self.emit('error', err)
})
stunnel.on('exit', function (code) {
stunnel.on('exit', (code) => {
self.clear()
if (code === 0) {
self.emit('stopped')
} else {
self.emit('error', new Error('Stunnel exited unexpectedly; code = ' + code))
self.emit('error', new Error(`Stunnel exited unexpectedly; code = ${code}`))
}
})
@@ -68,13 +68,13 @@ StunnelProcess.prototype.stop = function (done) {
}
module.exports = {
start: function (done, confDir) {
start (done, confDir) {
done = once(done)
var stunnel = new StunnelProcess(confDir)
const stunnel = new StunnelProcess(confDir)
stunnel.once('error', done.bind(done))
stunnel.once('started', done.bind(done, null, stunnel))
},
stop: function (stunnel, done) {
stop (stunnel, done) {
stunnel.removeAllListeners()
stunnel.stop()
stunnel.once('error', done.bind(done))

12
test/lib/unref.js
View File

@@ -3,13 +3,13 @@
// as soon as there are no outstanding commands.
'use strict'
var redis = require('../../index')
var HOST = process.argv[2] || '127.0.0.1'
var PORT = process.argv[3]
var args = PORT ? [PORT, HOST] : [HOST]
const redis = require('../../index')
const HOST = process.argv[2] || '127.0.0.1'
const PORT = process.argv[3]
const args = PORT ? [PORT, HOST] : [HOST]
var c = redis.createClient.apply(redis, args)
c.info(function (err, reply) {
const c = redis.createClient.apply(redis, args)
c.info((err, reply) => {
if (err) process.exit(-1)
if (!reply.length) process.exit(-1)
process.stdout.write(reply.length.toString())

310
test/multi.spec.js
View File

@@ -1,28 +1,28 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var utils = require('../lib/utils')
var redis = config.redis
var zlib = require('zlib')
var client
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const utils = require('../lib/utils')
const redis = config.redis
const zlib = require('zlib')
let client
describe('The \'multi\' method', function () {
afterEach(function () {
describe('The \'multi\' method', () => {
afterEach(() => {
client.end(true)
})
describe('regression test', function () {
describe('regression test', () => {
it('saved buffers with charsets different than utf-8 (issue #913)', function (done) {
this.timeout(12000) // Windows tests on 0.10 are slow
client = redis.createClient()
var end = helper.callFuncAfter(done, 100)
const end = helper.callFuncAfter(done, 100)
// Some random object created from http://beta.json-generator.com/
var testObj = {
const testObj = {
'Id': '5642c4c33d4667c4a1fefd99',
'index': 0,
'guid': '5baf1f1c-7621-41e7-ae7a-f8c6f3199b0f',
@@ -53,27 +53,27 @@ describe('The \'multi\' method', function () {
return
}
// To demonstrate a big payload for hash set field values, let's create a big array
var testArr = []
var i = 0
const testArr = []
let i = 0
for (; i < 80; i++) {
var newObj = JSON.parse(JSON.stringify(testObj))
const newObj = JSON.parse(JSON.stringify(testObj))
testArr.push(newObj)
}
var json = JSON.stringify(testArr)
zlib.deflate(Buffer.from(json), function (err, buffer) {
const json = JSON.stringify(testArr)
zlib.deflate(Buffer.from(json), (err, buffer) => {
if (err) {
done(err)
return
}
var multi = client.multi()
const multi = client.multi()
multi.del('SOME_KEY')
for (i = 0; i < 100; i++) {
multi.hset('SOME_KEY', 'SOME_FIELD' + i, buffer)
multi.hset('SOME_KEY', `SOME_FIELD${i}`, buffer)
}
multi.exec(function (err, res) {
multi.exec((err, res) => {
if (err) {
done(err)
return
@@ -86,19 +86,19 @@ describe('The \'multi\' method', function () {
})
})
describe('pipeline limit', function () {
describe('pipeline limit', () => {
it('do not exceed maximum string size', function (done) {
this.timeout(process.platform !== 'win32' ? 10000 : 35000) // Windows tests are horribly slow
// Triggers a RangeError: Invalid string length if not handled properly
client = redis.createClient()
var multi = client.multi()
var i = Math.pow(2, 28)
const multi = client.multi()
let i = Math.pow(2, 28)
while (i > 0) {
i -= 10230
multi.set('foo' + i, 'bar' + new Array(1024).join('1234567890'))
multi.set(`foo${i}`, `bar${new Array(1024).join('1234567890')}`)
}
client.on('ready', function () {
multi.exec(function (err, res) {
client.on('ready', () => {
multi.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 26241)
})
@@ -107,67 +107,66 @@ describe('The \'multi\' method', function () {
})
})
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
describe('when not connected', function () {
beforeEach(function (done) {
var end = helper.callFuncAfter(done, 2)
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
describe('when not connected', () => {
beforeEach((done) => {
const end = helper.callFuncAfter(done, 2)
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.once('ready', () => {
client.quit(end)
})
client.once('end', end)
})
it('reports an error', function (done) {
var multi = client.multi()
var notBuffering = multi.exec(function (err, res) {
it('reports an error', (done) => {
const multi = client.multi()
multi.exec((err, res) => {
assert(err.message.match(/The connection is already closed/))
done()
})
assert.strictEqual(notBuffering, false)
})
it('reports an error if promisified', function () {
return client.multi().execAsync().catch(function (err) {
it('reports an error if promisified', () => {
return client.multi().execAsync().catch((err) => {
assert(err.message.match(/The connection is already closed/))
})
})
})
describe('when connected', function () {
beforeEach(function () {
describe('when connected', () => {
beforeEach(() => {
client = redis.createClient.apply(null, args)
})
describe('monitor and transactions do not work together', function () {
it('results in a execabort', function (done) {
describe('monitor and transactions do not work together', () => {
it('results in a execabort', (done) => {
// Check that transactions in combination with monitor result in an error
client.monitor(function (e) {
client.on('error', function (err) {
client.monitor((e) => {
client.on('error', (err) => {
assert.strictEqual(err.code, 'EXECABORT')
client.end(false)
done()
})
var multi = client.multi()
const multi = client.multi()
multi.set('hello', 'world')
multi.exec()
})
})
it('results in a execabort #2', function (done) {
it('results in a execabort #2', (done) => {
// Check that using monitor with a transactions results in an error
client.multi().set('foo', 'bar').monitor().exec(function (err, res) {
client.multi().set('foo', 'bar').monitor().exec((err, res) => {
assert.strictEqual(err.code, 'EXECABORT')
client.end(false)
done()
})
})
it('sanity check', function (done) {
it('sanity check', (done) => {
// Remove the listener and add it back again after the error
var mochaListener = helper.removeMochaListener()
process.on('uncaughtException', function () {
const mochaListener = helper.removeMochaListener()
process.on('uncaughtException', () => {
helper.removeMochaListener()
process.on('uncaughtException', mochaListener)
done()
@@ -177,7 +176,7 @@ describe('The \'multi\' method', function () {
client.sendCommand('multi')
client.sendCommand('set', ['foo', 'bar'])
client.sendCommand('get', ['foo'])
client.sendCommand('exec', function (err, res) {
client.sendCommand('exec', (err, res) => {
assert.strictEqual(err, null)
// res[0] is going to be the monitor result of set
// res[1] is going to be the result of the set command
@@ -189,30 +188,30 @@ describe('The \'multi\' method', function () {
})
})
it('executes a pipelined multi properly in combination with the offline queue', function (done) {
var multi1 = client.multi()
it('executes a pipelined multi properly in combination with the offline queue', (done) => {
const multi1 = client.multi()
multi1.set('m1', '123')
multi1.get('m1')
multi1.exec(done)
assert.strictEqual(client.offlineQueue.length, 4)
})
it('executes a pipelined multi properly after a reconnect in combination with the offline queue', function (done) {
client.once('ready', function () {
it('executes a pipelined multi properly after a reconnect in combination with the offline queue', (done) => {
client.once('ready', () => {
client.stream.destroy()
var called = false
var multi1 = client.multi()
let called = false
const multi1 = client.multi()
multi1.set('m1', '123')
multi1.get('m1')
multi1.exec(function (err, res) {
multi1.exec((err, res) => {
assert(!err)
called = true
})
client.once('ready', function () {
var multi1 = client.multi()
client.once('ready', () => {
const multi1 = client.multi()
multi1.set('m2', '456')
multi1.get('m2')
multi1.exec(function (err, res) {
multi1.exec((err, res) => {
assert(called)
assert(!err)
assert.strictEqual(res[1], '456')
@@ -223,35 +222,35 @@ describe('The \'multi\' method', function () {
})
})
describe('when connection is broken', function () {
it.skip('return an error even if connection is in broken mode if callback is present', function (done) {
describe('when connection is broken', () => {
it.skip('return an error even if connection is in broken mode if callback is present', (done) => {
client = redis.createClient({
host: 'somewhere',
port: 6379,
retryStrategy: function () {}
retryStrategy () {}
})
client.on('error', function (err) {
client.on('error', (err) => {
if (/Redis connection in broken state/.test(err.message)) {
done()
}
})
client.multi([['set', 'foo', 'bar'], ['get', 'foo']]).exec(function (err, res) {
client.multi([['set', 'foo', 'bar'], ['get', 'foo']]).exec((err, res) => {
// assert(/Redis connection in broken state/.test(err.message));
assert.strictEqual(err.errors.length, 2)
assert.strictEqual(err.errors[0].args.length, 2)
})
})
it.skip('does not emit an error twice if connection is in broken mode with no callback', function (done) {
it.skip('does not emit an error twice if connection is in broken mode with no callback', (done) => {
client = redis.createClient({
host: 'somewhere',
port: 6379,
retryStrategy: function () {}
retryStrategy () {}
})
client.on('error', function (err) {
client.on('error', (err) => {
// Results in multiple done calls if test fails
if (/Redis connection in broken state/.test(err.message)) {
done()
@@ -262,40 +261,39 @@ describe('The \'multi\' method', function () {
})
})
describe('when ready', function () {
beforeEach(function (done) {
describe('when ready', () => {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('ready', function () {
client.flushdb(function (err) {
client.once('ready', () => {
client.flushdb((err) => {
return done(err)
})
})
})
it('returns an empty result array', function (done) {
var multi = client.multi()
var notBuffering = multi.exec(function (err, res) {
it('returns an empty result array', (done) => {
const multi = client.multi()
multi.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
done()
})
assert.strictEqual(notBuffering, true)
})
it('runs normal calls in-between multis', function (done) {
var multi1 = client.multi()
it('runs normal calls in-between multis', (done) => {
const multi1 = client.multi()
multi1.set('m1', '123')
client.set('m2', '456', done)
})
it('runs simultaneous multis with the same client', function (done) {
var end = helper.callFuncAfter(done, 2)
it('runs simultaneous multis with the same client', (done) => {
const end = helper.callFuncAfter(done, 2)
var multi1 = client.multi()
const multi1 = client.multi()
multi1.set('m1', '123')
multi1.get('m1')
var multi2 = client.multi()
const multi2 = client.multi()
multi2.set('m2', '456')
multi2.get('m2')
@@ -303,10 +301,10 @@ describe('The \'multi\' method', function () {
multi2.exec(helper.isDeepEqual(['OK', '456'], end))
})
it('runs simultaneous multis with the same client version 2', function (done) {
var end = helper.callFuncAfter(done, 2)
var multi2 = client.multi()
var multi1 = client.multi()
it('runs simultaneous multis with the same client version 2', (done) => {
const end = helper.callFuncAfter(done, 2)
const multi2 = client.multi()
const multi1 = client.multi()
multi2.set('m2', '456')
multi1.set('m1', '123')
@@ -318,43 +316,42 @@ describe('The \'multi\' method', function () {
multi2.exec(helper.isDeepEqual(['OK', '123', 'PONG'], end))
})
it('roles back a transaction when one command in a sequence of commands fails', function (done) {
var multi1, multi2
it('roles back a transaction when one command in a sequence of commands fails', (done) => {
// Provoke an error at queue time
multi1 = client.multi()
const multi1 = client.multi()
multi1.mset('multifoo', '10', 'multibar', '20', helper.isString('OK'))
multi1.set('foo2', helper.isError())
multi1.incr('multifoo')
multi1.incr('multibar')
multi1.exec(function () {
multi1.exec(() => {
// Redis 2.6.5+ will abort transactions with errors
// see: http://redis.io/topics/transactions
var multibarExpected = 1
var multifooExpected = 1
const multibarExpected = 1
const multifooExpected = 1
// Confirm that the previous command, while containing an error, still worked.
multi2 = client.multi()
const multi2 = client.multi()
multi2.incr('multibar', helper.isNumber(multibarExpected))
multi2.incr('multifoo', helper.isNumber(multifooExpected))
multi2.exec(helper.isDeepEqual([multibarExpected, multibarExpected], done))
})
})
it('roles back a transaction when one command in an array of commands fails', function (done) {
it('roles back a transaction when one command in an array of commands fails', (done) => {
// test nested multi-bulk replies
client.multi([
['mget', 'multifoo', 'multibar', helper.isDeepEqual([null, null])],
['set', 'foo2', helper.isError()],
['incr', 'multifoo'],
['incr', 'multibar']
]).exec(function (err, replies) {
]).exec((err, replies) => {
assert.notEqual(err, null)
assert.strictEqual(replies, undefined)
return done()
})
})
it('handles multiple operations being applied to a set', function (done) {
it('handles multiple operations being applied to a set', (done) => {
client.sadd('some set', 'mem 1')
client.sadd(['some set', 'mem 2'])
client.sadd('some set', 'mem 3')
@@ -371,7 +368,7 @@ describe('The \'multi\' method', function () {
['smembers', 'some set']
])
.scard('some set')
.exec(function (err, res) {
.exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res[0].length, 4)
assert.strictEqual(res[1], 1)
@@ -381,13 +378,13 @@ describe('The \'multi\' method', function () {
})
})
it('allows multiple operations to be performed using constructor with all kinds of syntax', function (done) {
var now = Date.now()
var arr = ['multihmset', 'multibar', 'multibaz']
var arr2 = ['some manner of key', 'otherTypes']
var arr3 = [5768, 'multibarx', 'multifoox']
var arr4 = ['mset', [578, 'multibar'], helper.isString('OK')]
var called = false
it('allows multiple operations to be performed using constructor with all kinds of syntax', (done) => {
const now = Date.now()
const arr = ['multihmset', 'multibar', 'multibaz']
const arr2 = ['some manner of key', 'otherTypes']
const arr3 = [5768, 'multibarx', 'multifoox']
const arr4 = ['mset', [578, 'multibar'], helper.isString('OK')]
let called = false
client.multi([
arr4,
[['mset', 'multifoo2', 'multibar2', 'multifoo3', 'multibar3'], helper.isString('OK')],
@@ -401,15 +398,15 @@ describe('The \'multi\' method', function () {
['hmset', 'multihmset', ['multibar', 'multibaz'], helper.isString('OK')]
])
.hmget(now, 123456789, 'otherTypes')
.hmget('key2', arr2, function noop () {})
.hmget('key2', arr2, () => {})
.hmget(['multihmset2', 'some manner of key', 'multibar3'])
.mget('multifoo2', ['multifoo3', 'multifoo'], function (err, res) {
.mget('multifoo2', ['multifoo3', 'multifoo'], (err, res) => {
assert.strictEqual(err, null)
assert(res[0], 'multifoo3')
assert(res[1], 'multifoo')
called = true
})
.exec(function (err, replies) {
.exec((err, replies) => {
assert(called)
assert.strictEqual(arr.length, 3)
assert.strictEqual(arr2.length, 2)
@@ -427,7 +424,7 @@ describe('The \'multi\' method', function () {
})
})
it('converts a non string key to a string', function (done) {
it('converts a non string key to a string', (done) => {
// TODO: Converting the key might change soon again.
client.multi().hmset(true, {
test: 123,
@@ -435,16 +432,15 @@ describe('The \'multi\' method', function () {
}).exec(done)
})
it('runs a multi without any further commands', function (done) {
var buffering = client.multi().exec(function (err, res) {
it('runs a multi without any further commands', (done) => {
client.multi().exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 0)
done()
})
assert(typeof buffering === 'boolean')
})
it('allows multiple operations to be performed using a chaining API', function (done) {
it('allows multiple operations to be performed using a chaining API', (done) => {
client.multi()
.mset('some', '10', 'keys', '20')
.incr('some')
@@ -453,7 +449,7 @@ describe('The \'multi\' method', function () {
.exec(helper.isDeepEqual(['OK', 11, 21, ['11', '21']], done))
})
it('allows multiple commands to work the same as normal to be performed using a chaining API', function (done) {
it('allows multiple commands to work the same as normal to be performed using a chaining API', (done) => {
client.multi()
.mset(['some', '10', 'keys', '20'])
.incr('some', helper.isNumber(11))
@@ -462,14 +458,14 @@ describe('The \'multi\' method', function () {
.exec(helper.isDeepEqual(['OK', 11, 21, ['11', '21']], done))
})
it('allows multiple commands to work the same as normal to be performed using a chaining API promisified', function () {
it('allows multiple commands to work the same as normal to be performed using a chaining API promisified', () => {
return client.multi()
.mset(['some', '10', 'keys', '20'])
.incr('some', helper.isNumber(11))
.incr(['keys'], helper.isNumber(21))
.mget('some', 'keys')
.execAsync()
.then(function (replies) {
.then((replies) => {
assert.strictEqual('OK', replies[0])
assert.strictEqual(11, replies[1])
assert.strictEqual(21, replies[2])
@@ -478,7 +474,7 @@ describe('The \'multi\' method', function () {
})
})
it('allows an array to be provided indicating multiple operations to perform', function (done) {
it('allows an array to be provided indicating multiple operations to perform', (done) => {
// test nested multi-bulk replies with nulls.
client.multi([
['mget', ['multifoo', 'some', 'random value', 'keys']],
@@ -486,7 +482,7 @@ describe('The \'multi\' method', function () {
]).exec(helper.isDeepEqual([[null, null, null, null], 1], done))
})
it('allows multiple operations to be performed on a hash', function (done) {
it('allows multiple operations to be performed on a hash', (done) => {
client.multi()
.hmset('multihash', 'a', 'foo', 'b', 1)
.hmset('multihash', {
@@ -494,7 +490,7 @@ describe('The \'multi\' method', function () {
things: 'here'
})
.hgetall('multihash')
.exec(function (err, replies) {
.exec((err, replies) => {
assert.strictEqual(null, err)
assert.strictEqual('OK', replies[0])
assert.strictEqual(Object.keys(replies[2]).length, 4)
@@ -506,8 +502,8 @@ describe('The \'multi\' method', function () {
})
})
it('reports EXECABORT exceptions when they occur (while queueing)', function (done) {
client.multi().config('bar').set('foo').set('bar').exec(function (err, reply) {
it('reports EXECABORT exceptions when they occur (while queueing)', (done) => {
client.multi().config('bar').set('foo').set('bar').exec((err, reply) => {
assert.strictEqual(err.code, 'EXECABORT')
assert.strictEqual(reply, undefined, 'The reply should have been discarded')
assert(err.message.match(/^EXECABORT/), 'Error message should begin with EXECABORT')
@@ -520,8 +516,8 @@ describe('The \'multi\' method', function () {
})
})
it('reports multiple exceptions when they occur (while EXEC is running)', function (done) {
client.multi().config('bar').debug('foo').eval('return {err=\'this is an error\'}', 0).exec(function (err, reply) {
it('reports multiple exceptions when they occur (while EXEC is running)', (done) => {
client.multi().config('bar').debug('foo').eval('return {err=\'this is an error\'}', 0).exec((err, reply) => {
assert.strictEqual(err, null)
assert.strictEqual(reply.length, 3)
assert.strictEqual(reply[0].code, 'ERR')
@@ -535,8 +531,8 @@ describe('The \'multi\' method', function () {
})
})
it('reports multiple exceptions when they occur (while EXEC is running) promisified', function () {
return client.multi().config('bar').debug('foo').eval('return {err=\'this is an error\'}', 0).execAsync().then(function (reply) {
it('reports multiple exceptions when they occur (while EXEC is running) promisified', () => {
return client.multi().config('bar').debug('foo').eval('return {err=\'this is an error\'}', 0).execAsync().then((reply) => {
assert.strictEqual(reply.length, 3)
assert.strictEqual(reply[0].code, 'ERR')
assert.strictEqual(reply[0].command, 'CONFIG')
@@ -548,11 +544,11 @@ describe('The \'multi\' method', function () {
})
})
it('reports multiple exceptions when they occur (while EXEC is running) and calls cb', function (done) {
var multi = client.multi()
it('reports multiple exceptions when they occur (while EXEC is running) and calls cb', (done) => {
const multi = client.multi()
multi.config('bar', helper.isError())
multi.set('foo', 'bar', helper.isString('OK'))
multi.debug('foo').exec(function (err, reply) {
multi.debug('foo').exec((err, reply) => {
assert.strictEqual(err, null)
assert.strictEqual(reply.length, 3)
assert.strictEqual(reply[0].code, 'ERR')
@@ -563,20 +559,20 @@ describe('The \'multi\' method', function () {
})
})
it('emits an error if no callback has been provided and execabort error occured', function (done) {
var multi = client.multi()
it('emits an error if no callback has been provided and execabort error occured', (done) => {
const multi = client.multi()
multi.config('bar')
multi.set('foo')
multi.exec()
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'EXECABORT')
done()
})
})
it('should work without any callback', function (done) {
var multi = client.multi()
it('should work without any callback', (done) => {
const multi = client.multi()
multi.set('baz', 'binary')
multi.set('foo', 'bar')
multi.exec()
@@ -584,9 +580,9 @@ describe('The \'multi\' method', function () {
client.get('foo', helper.isString('bar', done))
})
it('should not use a transaction with execAtomic if no command is used', function () {
var multi = client.multi()
var test = false
it('should not use a transaction with execAtomic if no command is used', () => {
const multi = client.multi()
let test = false
multi.execBatch = function () {
test = true
}
@@ -594,9 +590,9 @@ describe('The \'multi\' method', function () {
assert(test)
})
it('should not use a transaction with execAtomic if only one command is used', function () {
var multi = client.multi()
var test = false
it('should not use a transaction with execAtomic if only one command is used', () => {
const multi = client.multi()
let test = false
multi.execBatch = function () {
test = true
}
@@ -605,9 +601,9 @@ describe('The \'multi\' method', function () {
assert(test)
})
it('should use transaction with execAtomic and more than one command used', function (done) {
var multi = client.multi()
var test = false
it('should use transaction with execAtomic and more than one command used', (done) => {
const multi = client.multi()
let test = false
multi.execBatch = function () {
test = true
}
@@ -617,9 +613,9 @@ describe('The \'multi\' method', function () {
assert(!test)
})
it('do not mutate arguments in the multi constructor', function (done) {
var input = [['set', 'foo', 'bar'], ['get', 'foo']]
client.multi(input).exec(function (err, res) {
it('do not mutate arguments in the multi constructor', (done) => {
const input = [['set', 'foo', 'bar'], ['get', 'foo']]
client.multi(input).exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(input.length, 2)
assert.strictEqual(input[0].length, 3)
@@ -628,13 +624,13 @@ describe('The \'multi\' method', function () {
})
})
it('works properly after a reconnect. issue #897', function (done) {
it('works properly after a reconnect. issue #897', (done) => {
client.stream.destroy()
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'ECONNREFUSED')
})
client.on('ready', function () {
client.multi([['set', 'foo', 'bar'], ['get', 'foo']]).exec(function (err, res) {
client.on('ready', () => {
client.multi([['set', 'foo', 'bar'], ['get', 'foo']]).exec((err, res) => {
assert(!err)
assert.strictEqual(res[1], 'bar')
done()
@@ -642,10 +638,10 @@ describe('The \'multi\' method', function () {
})
})
it('emits error once if reconnecting after multi has been executed but not yet returned without callback', function (done) {
it('emits error once if reconnecting after multi has been executed but not yet returned without callback', (done) => {
// NOTE: If uncork is called async by postponing it to the next tick, this behavior is going to change.
// The command won't be processed anymore two errors are returned instead of one
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
client.get('foo', helper.isString('bar', done))
})
@@ -656,7 +652,7 @@ describe('The \'multi\' method', function () {
client.stream.destroy()
})
it('indivdual commands work properly with multi', function (done) {
it('indivdual commands work properly with multi', (done) => {
// Neither of the following work properly in a transactions:
// (This is due to Redis not returning the reply as expected / resulting in undefined behavior)
// (Likely there are more commands that do not work with a transaction)
@@ -675,8 +671,8 @@ describe('The \'multi\' method', function () {
}
assert.strictEqual(client.selectedDb, undefined)
var multi = client.multi()
multi.select(5, function (err, res) {
const multi = client.multi()
multi.select(5, (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(client.selectedDb, 5)
assert.strictEqual(res, 'OK')
@@ -684,13 +680,13 @@ describe('The \'multi\' method', function () {
})
// multi.client('reply', 'on', helper.isString('OK')); // Redis v.3.2
multi.set('foo', 'bar', helper.isString('OK'))
multi.info(function (err, res) {
multi.info((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.indexOf('# Server\r\nredis_version:'), 0)
assert.deepEqual(client.serverInfo.db5, { avg_ttl: 0, expires: 0, keys: 1 })
})
multi.get('foo', helper.isString('bar'))
multi.exec(function (err, res) {
multi.exec((err, res) => {
assert.strictEqual(err, null)
res[2] = res[2].substr(0, 10)
assert.deepEqual(res, ['OK', 'OK', '# Server\r\n', 'bar'])

416
test/node_redis.spec.js
View File

@@ -1,26 +1,26 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var fs = require('fs')
var path = require('path')
var intercept = require('intercept-stdout')
var config = require('./lib/config')
var helper = require('./helper')
var fork = require('child_process').fork
var redis = config.redis
var client
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const fs = require('fs')
const path = require('path')
const intercept = require('intercept-stdout')
const config = require('./lib/config')
const helper = require('./helper')
const fork = require('child_process').fork
const redis = config.redis
let client
describe('The nodeRedis client', function () {
it('individual commands sanity check', function (done) {
describe('The nodeRedis client', () => {
it('individual commands sanity check', (done) => {
// All commands should work the same in multi context or without
// Therefor individual commands always have to be handled in both cases
fs.readFile(path.resolve(__dirname, '../lib/individualCommands.js'), 'utf8', function (err, data) {
fs.readFile(path.resolve(__dirname, '../lib/individualCommands.js'), 'utf8', (err, data) => {
assert.strictEqual(err, null)
var clientPrototype = data.match(/(\n| = )RedisClient\.prototype.[a-zA-Z_]+/g)
var multiPrototype = data.match(/(\n| = )Multi\.prototype\.[a-zA-Z_]+/g)
const clientPrototype = data.match(/(\n| = )RedisClient\.prototype.[a-zA-Z_]+/g)
const multiPrototype = data.match(/(\n| = )Multi\.prototype\.[a-zA-Z_]+/g)
// Check that every entry RedisClient entry has a correspondent Multi entry
assert.strictEqual(clientPrototype.filter(function (entry) {
assert.strictEqual(clientPrototype.filter((entry) => {
return multiPrototype.indexOf(entry.replace('RedisClient', 'Multi')) === -1
}).length, 3) // multi and batch are included too
assert.strictEqual(clientPrototype.length, multiPrototype.length + 3)
@@ -30,74 +30,74 @@ describe('The nodeRedis client', function () {
})
})
it('convert minus to underscore in Redis function names', function (done) {
var names = Object.keys(redis.RedisClient.prototype)
it('convert minus to underscore in Redis function names', (done) => {
const names = Object.keys(redis.RedisClient.prototype)
client = redis.createClient()
for (var i = 0; i < names.length; i++) {
for (let i = 0; i < names.length; i++) {
assert(/^([a-zA-Z_][a-zA-Z_0-9]*)?$/.test(client[names[i]].name))
}
client.quit(done)
})
it('reset the parser while reconnecting (See #1190)', function (done) {
var client = redis.createClient({
retryStrategy: function () {
it('reset the parser while reconnecting (See #1190)', (done) => {
const client = redis.createClient({
retryStrategy () {
return 5
}
})
client.once('reconnecting', function () {
process.nextTick(function () {
client.once('reconnecting', () => {
process.nextTick(() => {
assert.strictEqual(client.replyParser.buffer, null)
done()
})
})
var partialInput = Buffer.from('$100\r\nabcdef')
const partialInput = Buffer.from('$100\r\nabcdef')
client.replyParser.execute(partialInput)
assert.strictEqual(client.replyParser.buffer.inspect(), partialInput.inspect())
client.stream.destroy()
})
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
afterEach(function () {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
afterEach(() => {
client.end(true)
})
describe('when connected', function () {
beforeEach(function (done) {
describe('when connected', () => {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
client.once('connect', function () {
client.once('connect', () => {
client.flushdb(done)
})
})
describe('duplicate', function () {
it('check if all options got copied properly', function (done) {
describe('duplicate', () => {
it('check if all options got copied properly', (done) => {
client.selectedDb = 2
var client2 = client.duplicate()
const client2 = client.duplicate()
assert.strictEqual(client.connectionId + 1, client2.connectionId)
assert.strictEqual(client2.selectedDb, 2)
assert(client.connected)
assert(!client2.connected)
for (var elem in client.options) {
for (const elem in client.options) {
if (client.options.hasOwnProperty(elem)) {
assert.strictEqual(client2.options[elem], client.options[elem])
}
}
client2.on('error', function (err) {
client2.on('error', (err) => {
assert.strictEqual(err.message, 'Connection forcefully ended and command aborted. It might have been processed.')
assert.strictEqual(err.command, 'SELECT')
assert(err instanceof Error)
assert.strictEqual(err.name, 'AbortError')
})
client2.on('ready', function () {
client2.on('ready', () => {
client2.end(true)
done()
})
})
it('check if all new options replaced the old ones', function (done) {
var client2 = client.duplicate({
it('check if all new options replaced the old ones', (done) => {
const client2 = client.duplicate({
noReadyCheck: true
})
assert(client.connected)
@@ -105,56 +105,56 @@ describe('The nodeRedis client', function () {
assert.strictEqual(client.options.noReadyCheck, undefined)
assert.strictEqual(client2.options.noReadyCheck, true)
assert.notDeepEqual(client.options, client2.options)
for (var elem in client.options) {
for (const elem in client.options) {
if (client.options.hasOwnProperty(elem)) {
if (elem !== 'noReadyCheck') {
assert.strictEqual(client2.options[elem], client.options[elem])
}
}
}
client2.on('ready', function () {
client2.on('ready', () => {
client2.end(true)
done()
})
})
it('works with a callback', function (done) {
client.duplicate(function (err, client) {
it('works with a callback', (done) => {
client.duplicate((err, client) => {
assert(!err)
assert.strictEqual(client.ready, true)
client.quit(done)
})
})
it('works with a callback and errors out', function (done) {
it('works with a callback and errors out', (done) => {
client.duplicate({
port: '9999'
}, function (err, client) {
}, (err, client) => {
assert.strictEqual(err.code, 'ECONNREFUSED')
done(client)
})
})
it('works with a promises', function () {
return client.duplicateAsync().then(function (client) {
it('works with a promises', () => {
return client.duplicateAsync().then((client) => {
assert.strictEqual(client.ready, true)
return client.quitAsync()
})
})
it('works with a promises and errors', function () {
it('works with a promises and errors', () => {
return client.duplicateAsync({
port: 9999
}).catch(function (err) {
}).catch((err) => {
assert.strictEqual(err.code, 'ECONNREFUSED')
})
})
})
describe('big data', function () {
describe('big data', () => {
// Check if the fast mode for big strings is working correct
it('safe strings that are bigger than 30000 characters', function (done) {
var str = 'foo ಠ_ಠ bar '
it('safe strings that are bigger than 30000 characters', (done) => {
let str = 'foo ಠ_ಠ bar '
while (str.length < 111111) {
str += str
}
@@ -162,13 +162,13 @@ describe('The nodeRedis client', function () {
client.get('foo', helper.isString(str, done))
})
it('safe strings that are bigger than 30000 characters with multi', function (done) {
var str = 'foo ಠ_ಠ bar '
it('safe strings that are bigger than 30000 characters with multi', (done) => {
let str = 'foo ಠ_ಠ bar '
while (str.length < 111111) {
str += str
}
var called = false
var temp = client.writeBuffers.bind(client)
let called = false
const temp = client.writeBuffers.bind(client)
assert(client.fireStrings)
client.writeBuffers = function (data) {
called = true
@@ -176,7 +176,7 @@ describe('The nodeRedis client', function () {
assert(!client.fireStrings)
temp(data)
}
client.multi().set('foo', str).get('foo', helper.isString(str)).exec(function (err, res) {
client.multi().set('foo', str).get('foo', helper.isString(str)).exec((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(called, true)
assert.strictEqual(res[1], str)
@@ -186,11 +186,11 @@ describe('The nodeRedis client', function () {
})
})
describe('sendCommand', function () {
it('omitting args should be fine', function (done) {
describe('sendCommand', () => {
it('omitting args should be fine', (done) => {
client.serverInfo = {}
client.sendCommand('info')
client.sendCommand('ping', function (err, res) {
client.sendCommand('ping', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'PONG')
// Check if the previous info command used the internal individual info command
@@ -198,7 +198,7 @@ describe('The nodeRedis client', function () {
client.serverInfo = {}
})
client.sendCommand('info', null, undefined)
client.sendCommand('ping', null, function (err, res) {
client.sendCommand('ping', null, (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'PONG')
// Check if the previous info command used the internal individual info command
@@ -206,14 +206,14 @@ describe('The nodeRedis client', function () {
client.serverInfo = {}
})
client.sendCommand('info', undefined, undefined)
client.sendCommand('ping', function (err, res) {
client.sendCommand('ping', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res, 'PONG')
// Check if the previous info command used the internal individual info command
assert.notDeepEqual(client.serverInfo, {})
client.serverInfo = {}
})
client.sendCommand('info', undefined, function (err, res) {
client.sendCommand('info', undefined, (err, res) => {
assert.strictEqual(err, null)
assert(/redis_version/.test(res))
// The individual info command should also be called by using sendCommand
@@ -222,7 +222,7 @@ describe('The nodeRedis client', function () {
})
})
it('using multi with sendCommand should work as individual command instead of using the internal multi', function (done) {
it('using multi with sendCommand should work as individual command instead of using the internal multi', (done) => {
// This is necessary to keep backwards compatibility and it is the only way to handle multis as you want in nodeRedis
client.sendCommand('multi')
client.sendCommand('set', ['foo', 'bar'], helper.isString('QUEUED'))
@@ -232,9 +232,9 @@ describe('The nodeRedis client', function () {
client.exec(helper.isDeepEqual(['OK', 'bar'], done))
})
it('multi should be handled special', function (done) {
it('multi should be handled special', (done) => {
client.sendCommand('multi', undefined, helper.isString('OK'))
var args = ['test', 'bla']
const args = ['test', 'bla']
client.sendCommand('set', args, helper.isString('QUEUED'))
assert.deepEqual(args, ['test', 'bla']) // Check args manipulation
client.get('test', helper.isString('QUEUED'))
@@ -242,7 +242,7 @@ describe('The nodeRedis client', function () {
client.exec(helper.isDeepEqual(['OK', 'bla'], done))
})
it('using another type as cb should throw', function () {
it('using another type as cb should throw', () => {
try {
client.sendCommand('set', ['test', 'bla'], [true])
throw new Error('failed')
@@ -257,28 +257,28 @@ describe('The nodeRedis client', function () {
}
})
it('command argument has to be of type string', function () {
it('command argument has to be of type string', () => {
try {
client.sendCommand(true, ['test', 'bla'], function () {})
client.sendCommand(true, ['test', 'bla'], () => {})
throw new Error('failed')
} catch (err) {
assert.strictEqual(err.message, 'Wrong input type "Boolean" for command name')
}
try {
client.sendCommand(undefined, ['test', 'bla'], function () {})
client.sendCommand(undefined, ['test', 'bla'], () => {})
throw new Error('failed')
} catch (err) {
assert.strictEqual(err.message, 'Wrong input type "undefined" for command name')
}
try {
client.sendCommand(null, ['test', 'bla'], function () {})
client.sendCommand(null, ['test', 'bla'], () => {})
throw new Error('failed')
} catch (err) {
assert.strictEqual(err.message, 'Wrong input type "null" for command name')
}
})
it('args may only be of type Array or undefined', function () {
it('args may only be of type Array or undefined', () => {
try {
client.sendCommand('info', 123)
throw new Error('failed')
@@ -287,18 +287,18 @@ describe('The nodeRedis client', function () {
}
})
it('passing a callback as args and as callback should throw', function () {
it('passing a callback as args and as callback should throw', () => {
try {
client.sendCommand('info', function a () {}, function b () {})
client.sendCommand('info', () => {}, () => {})
throw new Error('failed')
} catch (err) {
assert.strictEqual(err.message, 'Wrong input type "Function" for args')
}
})
it('multi should be handled special', function (done) {
it('multi should be handled special', (done) => {
client.sendCommand('multi', undefined, helper.isString('OK'))
var args = ['test', 'bla']
const args = ['test', 'bla']
client.sendCommand('set', args, helper.isString('QUEUED'))
assert.deepEqual(args, ['test', 'bla']) // Check args manipulation
client.get('test', helper.isString('QUEUED'))
@@ -306,52 +306,52 @@ describe('The nodeRedis client', function () {
client.exec(helper.isDeepEqual(['OK', 'bla'], done))
})
it('the args array may contain a arbitrary number of arguments', function (done) {
it('the args array may contain a arbitrary number of arguments', (done) => {
client.sendCommand('mset', ['foo', 1, 'bar', 2, 'baz', 3], helper.isString('OK'))
// As the multi command is handled individually by the user he also has to handle the return value
client.mget(['foo', 'bar', 'baz'], helper.isDeepEqual(['1', '2', '3'], done))
})
it('sendCommand with callback as args', function (done) {
client.sendCommand('abcdef', function (err, res) {
it('sendCommand with callback as args', (done) => {
client.sendCommand('abcdef', (err, res) => {
assert.strictEqual(err.message, 'ERR unknown command \'abcdef\'')
done()
})
})
})
describe('retryUnfulfilledCommands', function () {
it('should retry all commands instead of returning an error if a command did not yet return after a connection loss', function (done) {
var bclient = redis.createClient({
describe('retryUnfulfilledCommands', () => {
it('should retry all commands instead of returning an error if a command did not yet return after a connection loss', (done) => {
const bclient = redis.createClient({
retryUnfulfilledCommands: true
})
bclient.blpop('blocking list 2', 5, function (err, value) {
bclient.blpop('blocking list 2', 5, (err, value) => {
assert.strictEqual(value[0], 'blocking list 2')
assert.strictEqual(value[1], 'initial value')
bclient.end(true)
done(err)
})
bclient.once('ready', function () {
setTimeout(function () {
bclient.once('ready', () => {
setTimeout(() => {
bclient.stream.destroy()
client.rpush('blocking list 2', 'initial value', helper.isNumber(1))
}, 100)
})
})
it('should retry all commands even if the offline queue is disabled', function (done) {
var bclient = redis.createClient({
it('should retry all commands even if the offline queue is disabled', (done) => {
const bclient = redis.createClient({
enableOfflineQueue: false,
retryUnfulfilledCommands: true
})
bclient.once('ready', function () {
bclient.blpop('blocking list 2', 5, function (err, value) {
bclient.once('ready', () => {
bclient.blpop('blocking list 2', 5, (err, value) => {
assert.strictEqual(value[0], 'blocking list 2')
assert.strictEqual(value[1], 'initial value')
bclient.end(true)
done(err)
})
setTimeout(function () {
setTimeout(() => {
bclient.stream.destroy()
client.rpush('blocking list 2', 'initial value', helper.isNumber(1))
}, 100)
@@ -359,41 +359,41 @@ describe('The nodeRedis client', function () {
})
})
describe('.end', function () {
it('used without flush / flush set to false', function (done) {
var finished = false
var end = helper.callFuncAfter(function () {
describe('.end', () => {
it('used without flush / flush set to false', (done) => {
let finished = false
const end = helper.callFuncAfter(() => {
if (!finished) {
done(new Error('failed'))
}
}, 20)
var cb = function (err, res) {
const cb = function (err, res) {
assert(/Connection forcefully ended|The connection is already closed./.test(err.message))
assert.strictEqual(err.code, 'NR_CLOSED')
end()
}
for (var i = 0; i < 20; i++) {
for (let i = 0; i < 20; i++) {
if (i === 10) {
client.end()
}
client.set('foo', 'bar', cb)
}
client.on('warning', function () {}) // Ignore deprecation message
setTimeout(function () {
client.on('warning', () => {}) // Ignore deprecation message
setTimeout(() => {
finished = true
done()
}, 25)
})
it('used with flush set to true', function (done) {
var end = helper.callFuncAfter(function () {
it('used with flush set to true', (done) => {
const end = helper.callFuncAfter(() => {
done()
}, 20)
var cb = function (err, res) {
const cb = function (err, res) {
assert(/Connection forcefully ended|The connection is already closed./.test(err.message))
end()
}
for (var i = 0; i < 20; i++) {
for (let i = 0; i < 20; i++) {
if (i === 10) {
client.end(true)
client.stream.write('foo') // Trigger an error on the closed stream that we ignore
@@ -402,14 +402,14 @@ describe('The nodeRedis client', function () {
}
})
it('emits an aggregate error if no callback was present for multiple commands in debugMode', function (done) {
it('emits an aggregate error if no callback was present for multiple commands in debugMode', (done) => {
redis.debugMode = true
var unhookIntercept = intercept(function (data) {
const unhookIntercept = intercept((data) => {
return '' // Don't print the debug messages
})
client.set('foo', 'bar')
client.set('baz', 'hello world')
client.on('error', function (err) {
client.on('error', (err) => {
assert(err instanceof Error)
assert(err instanceof redis.AbortError)
assert(err instanceof redis.AggregateError)
@@ -428,13 +428,13 @@ describe('The nodeRedis client', function () {
redis.debugMode = false
})
it('emits an abort error if no callback was present for a single commands', function (done) {
it('emits an abort error if no callback was present for a single commands', (done) => {
redis.debugMode = true
var unhookIntercept = intercept(function (data) {
const unhookIntercept = intercept((data) => {
return '' // Don't print the debug messages
})
client.set('foo', 'bar')
client.on('error', function (err) {
client.on('error', (err) => {
assert(err instanceof Error)
assert(err instanceof redis.AbortError)
assert(!(err instanceof redis.AggregateError))
@@ -449,22 +449,22 @@ describe('The nodeRedis client', function () {
redis.debugMode = false
})
it('does not emit abort errors if no callback was present while not being in debugMode ', function (done) {
it('does not emit abort errors if no callback was present while not being in debugMode ', (done) => {
client.set('foo', 'bar')
client.end(true)
setTimeout(done, 100)
})
})
describe('commands after using .quit should fail', function () {
describe('commands after using .quit should fail', () => {
it('return an error in the callback', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
// TODO: Investigate why this test is failing hard and killing mocha if using '/tmp/redis.sock'.
// Seems like something is wrong with nyc while passing a socket connection to create client!
client = redis.createClient()
client.quit(function () {
client.get('foo', function (err, res) {
client.quit(() => {
client.get('foo', (err, res) => {
assert.strictEqual(err.message, 'Stream connection ended and command aborted. It might have been processed.')
assert.strictEqual(client.offlineQueue.length, 0)
done()
@@ -476,8 +476,8 @@ describe('The nodeRedis client', function () {
if (helper.redisProcess().spawnFailed()) this.skip()
client.quit()
setTimeout(function () {
client.get('foo', function (err, res) {
setTimeout(() => {
client.get('foo', (err, res) => {
assert.strictEqual(err.message, 'GET can\'t be processed. The connection is already closed.')
assert.strictEqual(err.command, 'GET')
assert.strictEqual(client.offlineQueue.length, 0)
@@ -489,23 +489,23 @@ describe('The nodeRedis client', function () {
it('emit an error', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
client.quit()
client.on('error', function (err) {
client.on('error', (err) => {
assert.strictEqual(err.message, 'SET can\'t be processed. The connection is already closed.')
assert.strictEqual(err.command, 'SET')
assert.strictEqual(client.offlineQueue.length, 0)
done()
})
setTimeout(function () {
setTimeout(() => {
client.set('foo', 'bar')
}, 50)
})
})
describe('when redis closes unexpectedly', function () {
it('reconnects and can retrieve the pre-existing data', function (done) {
describe('when redis closes unexpectedly', () => {
it('reconnects and can retrieve the pre-existing data', (done) => {
client.on('reconnecting', function onRecon (params) {
client.on('connect', function onConnect () {
var end = helper.callFuncAfter(function () {
const end = helper.callFuncAfter(() => {
client.removeListener('connect', onConnect)
client.removeListener('reconnecting', onRecon)
assert.strictEqual(client.serverInfo.db0.keys, 2)
@@ -520,7 +520,7 @@ describe('The nodeRedis client', function () {
})
client.set('recon 1', 'one')
client.set('recon 2', 'two', function (err, res) {
client.set('recon 2', 'two', (err, res) => {
assert.strictEqual(err, null)
// Do not do this in normal programs. This is to simulate the server closing on us.
// For orderly shutdown in normal programs, do client.quit()
@@ -528,7 +528,7 @@ describe('The nodeRedis client', function () {
})
})
it('reconnects properly when monitoring', function (done) {
it('reconnects properly when monitoring', (done) => {
client.on('reconnecting', function onRecon (params) {
client.on('ready', function onReady () {
assert.strictEqual(client.monitoring, true, 'monitoring after reconnect')
@@ -540,10 +540,10 @@ describe('The nodeRedis client', function () {
assert.strictEqual(client.monitoring, false, 'monitoring off at start')
client.set('recon 1', 'one')
client.monitor(function (err, res) {
client.monitor((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(client.monitoring, true, 'monitoring on after monitor()')
client.set('recon 2', 'two', function (err, res) {
client.set('recon 2', 'two', (err, res) => {
assert.strictEqual(err, null)
// Do not do this in normal programs. This is to simulate the server closing on us.
// For orderly shutdown in normal programs, do client.quit()
@@ -552,13 +552,13 @@ describe('The nodeRedis client', function () {
})
})
describe('and it\'s subscribed to a channel', function () {
describe('and it\'s subscribed to a channel', () => {
// "Connection in subscriber mode, only subscriber commands may be used"
it('reconnects, unsubscribes, and can retrieve the pre-existing data', function (done) {
client.on('ready', function onConnect () {
it('reconnects, unsubscribes, and can retrieve the pre-existing data', (done) => {
client.on('ready', () => {
client.unsubscribe(helper.isNotError())
client.on('unsubscribe', function (channel, count) {
client.on('unsubscribe', (channel, count) => {
// we should now be out of subscriber mode.
assert.strictEqual(channel, 'recon channel')
assert.strictEqual(count, 0)
@@ -567,7 +567,7 @@ describe('The nodeRedis client', function () {
})
client.set('recon 1', 'one')
client.subscribe('recon channel', function (err, res) {
client.subscribe('recon channel', (err, res) => {
assert.strictEqual(err, null)
// Do not do this in normal programs. This is to simulate the server closing on us.
// For orderly shutdown in normal programs, do client.quit()
@@ -575,11 +575,11 @@ describe('The nodeRedis client', function () {
})
})
it('reconnects, unsubscribes, and can retrieve the pre-existing data of a explicit channel', function (done) {
client.on('ready', function onConnect () {
it('reconnects, unsubscribes, and can retrieve the pre-existing data of a explicit channel', (done) => {
client.on('ready', () => {
client.unsubscribe('recon channel', helper.isNotError())
client.on('unsubscribe', function (channel, count) {
client.on('unsubscribe', (channel, count) => {
// we should now be out of subscriber mode.
assert.strictEqual(channel, 'recon channel')
assert.strictEqual(count, 0)
@@ -588,7 +588,7 @@ describe('The nodeRedis client', function () {
})
client.set('recon 1', 'one')
client.subscribe('recon channel', function (err, res) {
client.subscribe('recon channel', (err, res) => {
assert.strictEqual(err, null)
// Do not do this in normal programs. This is to simulate the server closing on us.
// For orderly shutdown in normal programs, do client.quit()
@@ -597,13 +597,13 @@ describe('The nodeRedis client', function () {
})
})
describe('domain', function () {
it('allows client to be executed from within domain', function (done) {
describe('domain', () => {
it('allows client to be executed from within domain', (done) => {
// eslint-disable-next-line
var domain = require('domain').create()
domain.run(function () {
client.set('domain', 'value', function (err, res) {
domain.run(() => {
client.set('domain', 'value', (err, res) => {
assert.strictEqual(err, null)
assert.ok(process.domain)
throw new Error('ohhhh noooo')
@@ -611,20 +611,20 @@ describe('The nodeRedis client', function () {
})
// this is the expected and desired behavior
domain.on('error', function (err) {
domain.on('error', (err) => {
assert.strictEqual(err.message, 'ohhhh noooo')
domain.exit()
done()
})
})
it('keeps the same domain by using the offline queue', function (done) {
it('keeps the same domain by using the offline queue', (done) => {
client.end(true)
client = redis.createClient()
// eslint-disable-next-line
var testDomain = require('domain').create()
testDomain.run(function () {
client.set('FOOBAR', 'def', function () {
testDomain.run(() => {
client.set('FOOBAR', 'def', () => {
assert.strictEqual(process.domain, testDomain)
done()
})
@@ -633,17 +633,17 @@ describe('The nodeRedis client', function () {
require('domain').create()
})
it('catches all errors from within the domain', function (done) {
it('catches all errors from within the domain', (done) => {
// eslint-disable-next-line
var domain = require('domain').create()
domain.run(function () {
domain.run(() => {
// Trigger an error within the domain
client.end(true)
client.set('domain', 'value')
})
domain.on('error', function (err) {
domain.on('error', (err) => {
assert.strictEqual(err.message, 'SET can\'t be processed. The connection is already closed.')
domain.exit()
done()
@@ -652,11 +652,11 @@ describe('The nodeRedis client', function () {
})
})
describe('utf8', function () {
it('handles utf-8 keys', function (done) {
var utf8Sample = 'ಠ_ಠ'
describe('utf8', () => {
it('handles utf-8 keys', (done) => {
const utf8Sample = 'ಠ_ಠ'
client.set(['utf8test', utf8Sample], helper.isString('OK'))
client.get(['utf8test'], function (err, obj) {
client.get(['utf8test'], (err, obj) => {
assert.strictEqual(utf8Sample, obj)
done(err)
})
@@ -664,18 +664,18 @@ describe('The nodeRedis client', function () {
})
})
describe('unref', function () {
describe('unref', () => {
it('exits subprocess as soon as final command is processed', function (done) {
this.timeout(12000)
var args = config.HOST[ip] ? [config.HOST[ip], config.PORT] : [ip]
var external = fork('./test/lib/unref.js', args)
const args = config.HOST[ip] ? [config.HOST[ip], config.PORT] : [ip]
const external = fork('./test/lib/unref.js', args)
var id = setTimeout(function () {
const id = setTimeout(() => {
external.kill()
done(new Error('unref subprocess timed out'))
}, 8000)
external.on('close', function (code) {
external.on('close', (code) => {
clearTimeout(id)
assert.strictEqual(code, 0)
done()
@@ -683,16 +683,16 @@ describe('The nodeRedis client', function () {
})
})
describe('execution order / fire query while loading', function () {
it('keep execution order for commands that may fire while redis is still loading', function (done) {
describe('execution order / fire query while loading', () => {
it('keep execution order for commands that may fire while redis is still loading', (done) => {
client = redis.createClient.apply(null, args)
var fired = false
client.set('foo', 'bar', function (err, res) {
let fired = false
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(fired, false)
done()
})
client.info(function (err, res) {
client.info((err, res) => {
assert.strictEqual(err, null)
fired = true
})
@@ -721,19 +721,19 @@ describe('The nodeRedis client', function () {
// });
})
describe('protocol error', function () {
it('should gracefully recover and only fail on the already send commands', function (done) {
describe('protocol error', () => {
it('should gracefully recover and only fail on the already send commands', (done) => {
client = redis.createClient.apply(null, args)
var error
client.on('error', function (err) {
let error
client.on('error', (err) => {
assert.strictEqual(err.message, 'Protocol error, got "a" as reply type byte. Please report this.')
assert.strictEqual(err, error)
assert(err instanceof redis.ParserError)
// After the hard failure work properly again. The set should have been processed properly too
client.get('foo', helper.isString('bar', done))
})
client.once('ready', function () {
client.set('foo', 'bar', function (err, res) {
client.once('ready', () => {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'Fatal error encountered. Command aborted. It might have been processed.')
assert.strictEqual(err.code, 'NR_FATAL')
assert(err instanceof redis.AbortError)
@@ -741,7 +741,7 @@ describe('The nodeRedis client', function () {
})
// Make sure we call execute out of the reply
// ready is called in a reply
process.nextTick(function () {
process.nextTick(() => {
// Fail the set answer. Has no corresponding command obj and will therefore land in the error handler and set
client.replyParser.execute(Buffer.from('a*1\r*1\r$1`zasd\r\na'))
})
@@ -749,22 +749,22 @@ describe('The nodeRedis client', function () {
})
})
describe('enableOfflineQueue', function () {
describe('true', function () {
it('does not return an error and enqueues operation', function (done) {
describe('enableOfflineQueue', () => {
describe('true', () => {
it('does not return an error and enqueues operation', (done) => {
client = redis.createClient(9999)
var finished = false
client.on('error', function (e) {
let finished = false
client.on('error', (e) => {
// ignore, b/c expecting a "can't connect" error
})
setTimeout(function () {
client.set('foo', 'bar', function (err, result) {
setTimeout(() => {
client.set('foo', 'bar', (err, result) => {
if (!finished) done(err)
assert.strictEqual(err.message, 'Connection forcefully ended and command aborted.')
})
setTimeout(function () {
setTimeout(() => {
assert.strictEqual(client.offlineQueue.length, 1)
finished = true
done()
@@ -772,17 +772,17 @@ describe('The nodeRedis client', function () {
}, 50)
})
it.skip('enqueues operation and keep the queue while trying to reconnect', function (done) {
it.skip('enqueues operation and keep the queue while trying to reconnect', (done) => {
client = redis.createClient(9999, null, {
retryStrategy: function (options) {
retryStrategy (options) {
if (options.attempt < 4) {
return 200
}
}
})
var i = 0
let i = 0
client.on('error', function (err) {
client.on('error', (err) => {
if (err.code === 'CONNECTION_BROKEN') {
assert(i, 3)
assert.strictEqual(client.offlineQueue.length, 0)
@@ -799,7 +799,7 @@ describe('The nodeRedis client', function () {
}
})
client.on('reconnecting', function (params) {
client.on('reconnecting', (params) => {
i++
assert.strictEqual(params.attempt, i)
assert.strictEqual(params.timesConnected, 0)
@@ -810,34 +810,34 @@ describe('The nodeRedis client', function () {
// Should work with either a callback or without
client.set('baz', 13)
client.set('foo', 'bar', function (err, result) {
client.set('foo', 'bar', (err, result) => {
assert(i, 3)
assert(err)
assert.strictEqual(client.offlineQueue.length, 0)
})
})
it('flushes the command queue if connection is lost', function (done) {
it('flushes the command queue if connection is lost', (done) => {
client = redis.createClient()
client.once('ready', function () {
var multi = client.multi()
client.once('ready', () => {
const multi = client.multi()
multi.config('bar')
var cb = function (err, reply) {
const cb = function (err, reply) {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
}
for (var i = 0; i < 12; i += 3) {
client.set('foo' + i, 'bar' + i)
multi.set('foo' + (i + 1), 'bar' + (i + 1), cb)
multi.set('foo' + (i + 2), 'bar' + (i + 2))
for (let i = 0; i < 12; i += 3) {
client.set(`foo${i}`, `bar${i}`)
multi.set(`foo${i + 1}`, `bar${i + 1}`, cb)
multi.set(`foo${i + 2}`, `bar${i + 2}`)
}
multi.exec()
assert.strictEqual(client.commandQueue.length, 15)
helper.killConnection(client)
})
var end = helper.callFuncAfter(done, 3)
client.on('error', function (err) {
const end = helper.callFuncAfter(done, 3)
client.on('error', (err) => {
if (err.command === 'EXEC') {
assert.strictEqual(client.commandQueue.length, 0)
assert.strictEqual(err.errors.length, 9)
@@ -860,27 +860,27 @@ describe('The nodeRedis client', function () {
})
})
describe('false', function () {
it('stream not writable', function (done) {
describe('false', () => {
it('stream not writable', (done) => {
client = redis.createClient({
enableOfflineQueue: false
})
client.on('ready', function () {
client.on('ready', () => {
client.stream.destroy()
client.set('foo', 'bar', function (err, res) {
client.set('foo', 'bar', (err, res) => {
assert.strictEqual(err.message, 'SET can\'t be processed. Stream not writeable.')
done()
})
})
})
it('emit an error and does not enqueues operation', function (done) {
it('emit an error and does not enqueues operation', (done) => {
client = redis.createClient(9999, null, {
enableOfflineQueue: false
})
var end = helper.callFuncAfter(done, 3)
const end = helper.callFuncAfter(done, 3)
client.on('error', function (err) {
client.on('error', (err) => {
assert(/offline queue is deactivated|ECONNREFUSED/.test(err.message))
assert.strictEqual(client.commandQueue.length, 0)
end()
@@ -888,8 +888,8 @@ describe('The nodeRedis client', function () {
client.set('foo', 'bar')
assert.doesNotThrow(function () {
client.set('foo', 'bar', function (err) {
assert.doesNotThrow(() => {
client.set('foo', 'bar', (err) => {
// should callback with an error
assert.ok(err)
setTimeout(end, 50)
@@ -897,33 +897,33 @@ describe('The nodeRedis client', function () {
})
})
it('flushes the command queue if connection is lost', function (done) {
it('flushes the command queue if connection is lost', (done) => {
client = redis.createClient({
enableOfflineQueue: false
})
redis.debugMode = true
var unhookIntercept = intercept(function () {
const unhookIntercept = intercept(() => {
return ''
})
client.once('ready', function () {
var multi = client.multi()
client.once('ready', () => {
const multi = client.multi()
multi.config('bar')
var cb = function (err, reply) {
const cb = function (err, reply) {
assert.strictEqual(err.code, 'UNCERTAIN_STATE')
}
for (var i = 0; i < 12; i += 3) {
client.set('foo' + i, 'bar' + i)
multi.set('foo' + (i + 1), 'bar' + (i + 1), cb)
multi.set('foo' + (i + 2), 'bar' + (i + 2))
for (let i = 0; i < 12; i += 3) {
client.set(`foo${i}`, `bar${i}`)
multi.set(`foo${i + 1}`, `bar${i + 1}`, cb)
multi.set(`foo${i + 2}`, `bar${i + 2}`)
}
multi.exec()
assert.strictEqual(client.commandQueue.length, 15)
helper.killConnection(client)
})
var end = helper.callFuncAfter(done, 3)
client.on('error', function (err) {
const end = helper.callFuncAfter(done, 3)
client.on('error', (err) => {
assert.strictEqual(client.commandQueue.length, 0)
if (err.command === 'EXEC') {
assert.strictEqual(err.errors.length, 9)

46
test/prefix.spec.js
View File

@@ -1,34 +1,34 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
describe('prefix key names', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client = null
describe('prefix key names', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client = null
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient({
prefix: 'test:prefix:'
})
client.on('ready', function () {
client.flushdb(function (err) {
client.on('ready', () => {
client.flushdb((err) => {
done(err)
})
})
})
afterEach(function () {
afterEach(() => {
client.end(true)
})
it('auto prefix set / get', function (done) {
it('auto prefix set / get', (done) => {
client.set('key', 'value', helper.isString('OK'))
client.get('key', helper.isString('value'))
client.getrange('key', 1, -1, function (err, reply) {
client.getrange('key', 1, -1, (err, reply) => {
assert.strictEqual(reply, 'alue')
assert.strictEqual(err, null)
})
@@ -36,7 +36,7 @@ describe('prefix key names', function () {
// The key will be prefixed itself
client.exists('test:prefix:key', helper.isNumber(0))
client.mset('key2', 'value2', 'key3', 'value3')
client.keys('*', function (err, res) {
client.keys('*', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 3)
assert(res.indexOf('test:prefix:key') !== -1)
@@ -46,11 +46,11 @@ describe('prefix key names', function () {
})
})
it('auto prefix set / get with .batch', function (done) {
var batch = client.batch()
it('auto prefix set / get with .batch', (done) => {
const batch = client.batch()
batch.set('key', 'value', helper.isString('OK'))
batch.get('key', helper.isString('value'))
batch.getrange('key', 1, -1, function (err, reply) {
batch.getrange('key', 1, -1, (err, reply) => {
assert.strictEqual(reply, 'alue')
assert.strictEqual(err, null)
})
@@ -58,7 +58,7 @@ describe('prefix key names', function () {
// The key will be prefixed itself
batch.exists('test:prefix:key', helper.isNumber(0))
batch.mset('key2', 'value2', 'key3', 'value3')
batch.keys('*', function (err, res) {
batch.keys('*', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 3)
assert(res.indexOf('test:prefix:key') !== -1)
@@ -68,11 +68,11 @@ describe('prefix key names', function () {
batch.exec(done)
})
it('auto prefix set / get with .multi', function (done) {
var multi = client.multi()
it('auto prefix set / get with .multi', (done) => {
const multi = client.multi()
multi.set('key', 'value', helper.isString('OK'))
multi.get('key', helper.isString('value'))
multi.getrange('key', 1, -1, function (err, reply) {
multi.getrange('key', 1, -1, (err, reply) => {
assert.strictEqual(reply, 'alue')
assert.strictEqual(err, null)
})
@@ -80,7 +80,7 @@ describe('prefix key names', function () {
// The key will be prefixed itself
multi.exists('test:prefix:key', helper.isNumber(0))
multi.mset('key2', 'value2', 'key3', 'value3')
multi.keys('*', function (err, res) {
multi.keys('*', (err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res.length, 3)
assert(res.indexOf('test:prefix:key') !== -1)

330
test/pubsub.spec.js
View File

@@ -1,49 +1,49 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
describe('publish/subscribe', function () {
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var pub = null
var sub = null
var channel = 'test channel'
var channel2 = 'test channel 2'
var message = 'test message'
describe('publish/subscribe', () => {
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let pub = null
let sub = null
const channel = 'test channel'
const channel2 = 'test channel 2'
const message = 'test message'
beforeEach(function (done) {
var end = helper.callFuncAfter(done, 2)
beforeEach((done) => {
const end = helper.callFuncAfter(done, 2)
pub = redis.createClient.apply(null, args)
sub = redis.createClient.apply(null, args)
pub.once('connect', function () {
pub.flushdb(function () {
pub.once('connect', () => {
pub.flushdb(() => {
end()
})
})
sub.once('connect', function () {
sub.once('connect', () => {
end()
})
})
describe('disable resubscribe', function () {
beforeEach(function (done) {
describe('disable resubscribe', () => {
beforeEach((done) => {
sub.end(false)
sub = redis.createClient({
disableResubscribing: true
})
sub.once('connect', function () {
sub.once('connect', () => {
done()
})
})
it('does not fire subscribe events after reconnecting', function (done) {
var a = false
sub.on('subscribe', function (chnl, count) {
it('does not fire subscribe events after reconnecting', (done) => {
let a = false
sub.on('subscribe', (chnl, count) => {
if (chnl === channel2) {
if (a) {
return done(new Error('Test failed'))
@@ -53,9 +53,9 @@ describe('publish/subscribe', function () {
}
})
sub.on('reconnecting', function () {
sub.on('reconnecting', () => {
a = true
sub.on('ready', function () {
sub.on('ready', () => {
assert.strictEqual(sub.commandQueue.length, 0)
done()
})
@@ -65,30 +65,30 @@ describe('publish/subscribe', function () {
})
})
describe('stringNumbers and pub sub', function () {
beforeEach(function (done) {
describe('stringNumbers and pub sub', () => {
beforeEach((done) => {
sub.end(false)
sub = redis.createClient({
stringNumbers: true
})
sub.once('connect', function () {
sub.once('connect', () => {
done()
})
})
it('does not fire subscribe events after reconnecting', function (done) {
var i = 0
var end = helper.callFuncAfter(done, 2)
sub.on('subscribe', function (chnl, count) {
it('does not fire subscribe events after reconnecting', (done) => {
let i = 0
const end = helper.callFuncAfter(done, 2)
sub.on('subscribe', (chnl, count) => {
assert.strictEqual(typeof count, 'number')
assert.strictEqual(++i, count)
})
sub.on('unsubscribe', function (chnl, count) {
sub.on('unsubscribe', (chnl, count) => {
assert.strictEqual(typeof count, 'number')
assert.strictEqual(--i, count)
})
sub.subscribe(channel, channel2)
sub.unsubscribe(function (err, res) { // Do not pass a channel here!
sub.unsubscribe((err, res) => { // Do not pass a channel here!
if (err) throw err
assert.strictEqual(sub.pubSubMode, 2)
assert.deepEqual(sub.subscriptionSet, {})
@@ -99,10 +99,10 @@ describe('publish/subscribe', function () {
})
})
describe('subscribe', function () {
it('fires a subscribe event for each channel subscribed to even after reconnecting', function (done) {
var a = false
sub.on('subscribe', function (chnl, count) {
describe('subscribe', () => {
it('fires a subscribe event for each channel subscribed to even after reconnecting', (done) => {
let a = false
sub.on('subscribe', (chnl, count) => {
if (chnl === channel2) {
assert.strictEqual(2, count)
if (a) return done()
@@ -110,20 +110,20 @@ describe('publish/subscribe', function () {
}
})
sub.on('reconnecting', function () {
sub.on('reconnecting', () => {
a = true
})
sub.subscribe(channel, channel2)
})
it('fires a subscribe event for each channel as buffer subscribed to even after reconnecting', function (done) {
var a = false
it('fires a subscribe event for each channel as buffer subscribed to even after reconnecting', (done) => {
let a = false
sub.end(true)
sub = redis.createClient({
detectBuffers: true
})
sub.on('subscribe', function (chnl, count) {
sub.on('subscribe', (chnl, count) => {
if (chnl.inspect() === Buffer.from([0xAA, 0xBB, 0x00, 0xF0]).inspect()) {
assert.strictEqual(1, count)
if (a) {
@@ -133,23 +133,23 @@ describe('publish/subscribe', function () {
}
})
sub.on('reconnecting', function () {
sub.on('reconnecting', () => {
a = true
})
sub.subscribe(Buffer.from([0xAA, 0xBB, 0x00, 0xF0]), channel2)
})
it('receives messages on subscribed channel', function (done) {
var end = helper.callFuncAfter(done, 2)
sub.on('subscribe', function (chnl, count) {
pub.publish(channel, message, function (err, res) {
it('receives messages on subscribed channel', (done) => {
const end = helper.callFuncAfter(done, 2)
sub.on('subscribe', (chnl, count) => {
pub.publish(channel, message, (err, res) => {
helper.isNumber(1)(err, res)
end()
})
})
sub.on('message', function (chnl, msg) {
sub.on('message', (chnl, msg) => {
assert.strictEqual(chnl, channel)
assert.strictEqual(msg, message)
end()
@@ -158,16 +158,16 @@ describe('publish/subscribe', function () {
sub.subscribe(channel)
})
it('receives messages if subscribe is called after unsubscribe', function (done) {
var end = helper.callFuncAfter(done, 2)
sub.once('subscribe', function (chnl, count) {
pub.publish(channel, message, function (err, res) {
it('receives messages if subscribe is called after unsubscribe', (done) => {
const end = helper.callFuncAfter(done, 2)
sub.once('subscribe', (chnl, count) => {
pub.publish(channel, message, (err, res) => {
helper.isNumber(1)(err, res)
end()
})
})
sub.on('message', function (chnl, msg) {
sub.on('message', (chnl, msg) => {
assert.strictEqual(chnl, channel)
assert.strictEqual(msg, message)
end()
@@ -178,7 +178,7 @@ describe('publish/subscribe', function () {
sub.subscribe(channel)
})
it('handles SUB UNSUB MSG SUB', function (done) {
it('handles SUB UNSUB MSG SUB', (done) => {
sub.subscribe('chan8')
sub.subscribe('chan9')
sub.unsubscribe('chan9')
@@ -186,7 +186,7 @@ describe('publish/subscribe', function () {
sub.subscribe('chan9', done)
})
it('handles SUB UNSUB MSG SUB 2', function (done) {
it('handles SUB UNSUB MSG SUB 2', (done) => {
sub.psubscribe('abc*', helper.isDeepEqual([1, ['abc*']]))
sub.subscribe('xyz')
sub.unsubscribe('xyz')
@@ -194,21 +194,21 @@ describe('publish/subscribe', function () {
sub.subscribe('xyz', done)
})
it('emits end event if quit is called from within subscribe', function (done) {
it('emits end event if quit is called from within subscribe', (done) => {
sub.on('end', done)
sub.on('subscribe', function (chnl, count) {
sub.on('subscribe', (chnl, count) => {
sub.quit()
})
sub.subscribe(channel)
})
it('subscribe; close; resubscribe with prototype inherited property names', function (done) {
var count = 0
var channels = ['channel 1', 'channel 2']
var msg = ['hi from channel 1', 'hi from channel 2']
it('subscribe; close; resubscribe with prototype inherited property names', (done) => {
let count = 0
const channels = ['channel 1', 'channel 2']
const msg = ['hi from channel 1', 'hi from channel 2']
sub.on('message', function (channel, message) {
var n = Math.max(count - 1, 0)
sub.on('message', (channel, message) => {
const n = Math.max(count - 1, 0)
assert.strictEqual(channel, channels[n])
assert.strictEqual(message, msg[n])
if (count === 2) return done()
@@ -218,7 +218,7 @@ describe('publish/subscribe', function () {
sub.select(3)
sub.subscribe(channels)
sub.on('ready', function (err, results) {
sub.on('ready', (err, results) => {
if (err) throw err
pub.publish(channels[count], msg[count])
count++
@@ -228,28 +228,28 @@ describe('publish/subscribe', function () {
})
})
describe('multiple subscribe / unsubscribe commands', function () {
it('reconnects properly with pub sub and select command', function (done) {
var end = helper.callFuncAfter(done, 2)
describe('multiple subscribe / unsubscribe commands', () => {
it('reconnects properly with pub sub and select command', (done) => {
const end = helper.callFuncAfter(done, 2)
sub.select(3)
sub.set('foo', 'bar')
sub.set('failure', helper.isError()) // Triggering a warning while subscribing should work
sub.mget('foo', 'bar', 'baz', 'hello', 'world', helper.isDeepEqual(['bar', null, null, null, null]))
sub.subscribe('somechannel', 'another channel', function (err, res) {
sub.subscribe('somechannel', 'another channel', (err, res) => {
if (err) throw err
end()
sub.stream.destroy()
})
assert(sub.ready)
sub.on('ready', function () {
sub.on('ready', () => {
sub.unsubscribe()
sub.del('foo')
sub.info(end)
})
})
it('should not go into pubsub mode with unsubscribe commands', function (done) {
sub.on('unsubscribe', function (msg) {
it('should not go into pubsub mode with unsubscribe commands', (done) => {
sub.on('unsubscribe', (msg) => {
// The unsubscribe should not be triggered, as there was no corresponding channel
throw new Error('Test failed')
})
@@ -258,12 +258,12 @@ describe('publish/subscribe', function () {
sub.del('foo', done)
})
it('handles multiple channels with the same channel name properly, even with buffers', function (done) {
var channels = ['a', 'b', 'a', Buffer.from('a'), 'c', 'b']
var subscribedChannels = [1, 2, 2, 2, 3, 3]
var i = 0
it('handles multiple channels with the same channel name properly, even with buffers', (done) => {
const channels = ['a', 'b', 'a', Buffer.from('a'), 'c', 'b']
const subscribedChannels = [1, 2, 2, 2, 3, 3]
let i = 0
sub.subscribe(channels)
sub.on('subscribe', function (channel, count) {
sub.on('subscribe', (channel, count) => {
if (Buffer.isBuffer(channel)) {
assert.strictEqual(channel.inspect(), Buffer.from(channels[i]).inspect())
} else {
@@ -276,13 +276,13 @@ describe('publish/subscribe', function () {
sub.get('foo', done)
})
it('should only resubscribe to channels not unsubscribed earlier on a reconnect', function (done) {
it('should only resubscribe to channels not unsubscribed earlier on a reconnect', (done) => {
sub.subscribe('/foo', '/bar')
sub.batch().unsubscribe(['/bar'], function () {
pub.pubsub('channels', helper.isDeepEqual(['/foo'], function () {
sub.batch().unsubscribe(['/bar'], () => {
pub.pubsub('channels', helper.isDeepEqual(['/foo'], () => {
sub.stream.destroy()
sub.once('ready', function () {
pub.pubsub('channels', helper.isDeepEqual(['/foo'], function () {
sub.once('ready', () => {
pub.pubsub('channels', helper.isDeepEqual(['/foo'], () => {
sub.unsubscribe('/foo', done)
}))
})
@@ -290,22 +290,22 @@ describe('publish/subscribe', function () {
}).exec()
})
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Withouth callbacks', function (done) {
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Withouth callbacks', (done) => {
function subscribe (channels) {
sub.unsubscribe(helper.isNull)
sub.subscribe(channels, helper.isNull)
}
var all = false
var subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', function (msg, count) {
let all = false
const subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', (msg, count) => {
subscribeMsg.splice(subscribeMsg.indexOf(msg), 1)
if (subscribeMsg.length === 0 && all) {
assert.strictEqual(count, 3)
done()
}
})
var unsubscribeMsg = ['1', '3', '2']
sub.on('unsubscribe', function (msg, count) {
const unsubscribeMsg = ['1', '3', '2']
sub.on('unsubscribe', (msg, count) => {
unsubscribeMsg.splice(unsubscribeMsg.indexOf(msg), 1)
if (unsubscribeMsg.length === 0) {
assert.strictEqual(count, 0)
@@ -318,22 +318,22 @@ describe('publish/subscribe', function () {
subscribe(['5', 'test', 'bla'])
})
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Without callbacks', function (done) {
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Without callbacks', (done) => {
function subscribe (channels) {
sub.unsubscribe()
sub.subscribe(channels)
}
var all = false
var subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', function (msg, count) {
let all = false
const subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', (msg, count) => {
subscribeMsg.splice(subscribeMsg.indexOf(msg), 1)
if (subscribeMsg.length === 0 && all) {
assert.strictEqual(count, 3)
done()
}
})
var unsubscribeMsg = ['1', '3', '2']
sub.on('unsubscribe', function (msg, count) {
const unsubscribeMsg = ['1', '3', '2']
sub.on('unsubscribe', (msg, count) => {
unsubscribeMsg.splice(unsubscribeMsg.indexOf(msg), 1)
if (unsubscribeMsg.length === 0) {
assert.strictEqual(count, 0)
@@ -346,24 +346,24 @@ describe('publish/subscribe', function () {
subscribe(['5', 'test', 'bla'])
})
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Without callback and concret channels', function (done) {
it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Without callback and concret channels', (done) => {
function subscribe (channels) {
sub.unsubscribe(channels)
sub.unsubscribe(channels)
sub.subscribe(channels)
}
var all = false
var subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', function (msg, count) {
let all = false
const subscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('subscribe', (msg, count) => {
subscribeMsg.splice(subscribeMsg.indexOf(msg), 1)
if (subscribeMsg.length === 0 && all) {
assert.strictEqual(count, 6)
done()
}
})
var unsubscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('unsubscribe', function (msg, count) {
var pos = unsubscribeMsg.indexOf(msg)
const unsubscribeMsg = ['1', '3', '2', '5', 'test', 'bla']
sub.on('unsubscribe', (msg, count) => {
const pos = unsubscribeMsg.indexOf(msg)
if (pos !== -1) { unsubscribeMsg.splice(pos, 1) }
if (unsubscribeMsg.length === 0) {
all = true
@@ -375,27 +375,27 @@ describe('publish/subscribe', function () {
subscribe(['5', 'test', 'bla'])
})
it('unsubscribes, subscribes, unsubscribes... with pattern matching', function (done) {
it('unsubscribes, subscribes, unsubscribes... with pattern matching', (done) => {
function subscribe (channels, callback) {
sub.punsubscribe('prefix:*', helper.isNull)
sub.psubscribe(channels, function (err, res) {
sub.psubscribe(channels, (err, res) => {
helper.isNull(err)
if (callback) callback(err, res)
})
}
var all = false
var end = helper.callFuncAfter(done, 8)
var subscribeMsg = ['prefix:*', 'prefix:3', 'prefix:2', '5', 'test:a', 'bla']
sub.on('psubscribe', function (msg, count) {
let all = false
const end = helper.callFuncAfter(done, 8)
const subscribeMsg = ['prefix:*', 'prefix:3', 'prefix:2', '5', 'test:a', 'bla']
sub.on('psubscribe', (msg, count) => {
subscribeMsg.splice(subscribeMsg.indexOf(msg), 1)
if (subscribeMsg.length === 0) {
assert.strictEqual(count, 5)
all = true
}
})
var rest = 1
var unsubscribeMsg = ['prefix:*', 'prefix:*', 'prefix:*', '*']
sub.on('punsubscribe', function (msg, count) {
let rest = 1
const unsubscribeMsg = ['prefix:*', 'prefix:*', 'prefix:*', '*']
sub.on('punsubscribe', (msg, count) => {
unsubscribeMsg.splice(unsubscribeMsg.indexOf(msg), 1)
if (all) {
assert.strictEqual(unsubscribeMsg.length, 0)
@@ -406,20 +406,20 @@ describe('publish/subscribe', function () {
assert.strictEqual(count, rest++ - 1)
}
})
sub.on('pmessage', function (pattern, channel, msg) {
sub.on('pmessage', (pattern, channel, msg) => {
assert.strictEqual(msg, 'test')
assert.strictEqual(pattern, 'prefix:*')
assert.strictEqual(channel, 'prefix:1')
end()
})
subscribe(['prefix:*', 'prefix:3'], function () {
pub.publish('prefix:1', Buffer.from('test'), function () {
subscribe(['prefix:*', 'prefix:3'], () => {
pub.publish('prefix:1', Buffer.from('test'), () => {
subscribe(['prefix:2'])
subscribe(['5', 'test:a', 'bla'], function () {
subscribe(['5', 'test:a', 'bla'], () => {
assert(all)
})
sub.punsubscribe(function (err, res) {
sub.punsubscribe((err, res) => {
assert(!err)
assert.deepStrictEqual(res, [0, ['prefix:3', 'prefix:2', '5', 'test:a', 'bla']])
assert(all)
@@ -432,57 +432,57 @@ describe('publish/subscribe', function () {
})
})
describe('unsubscribe', function () {
it('fires an unsubscribe event', function (done) {
sub.on('subscribe', function (chnl, count) {
describe('unsubscribe', () => {
it('fires an unsubscribe event', (done) => {
sub.on('subscribe', (chnl, count) => {
sub.unsubscribe(channel)
})
sub.subscribe(channel)
sub.on('unsubscribe', function (chnl, count) {
sub.on('unsubscribe', (chnl, count) => {
assert.strictEqual(chnl, channel)
assert.strictEqual(count, 0)
return done()
})
})
it('puts client back into write mode', function (done) {
sub.on('subscribe', function (chnl, count) {
it('puts client back into write mode', (done) => {
sub.on('subscribe', (chnl, count) => {
sub.unsubscribe(channel)
})
sub.subscribe(channel)
sub.on('unsubscribe', function (chnl, count) {
sub.on('unsubscribe', (chnl, count) => {
pub.incr('foo', helper.isNumber(1, done))
})
})
it('sub executes callback when unsubscribe is called and there are no subscriptions', function (done) {
it('sub executes callback when unsubscribe is called and there are no subscriptions', (done) => {
sub.unsubscribe(helper.isDeepEqual([0, []], done))
})
it('pub executes callback when unsubscribe is called and there are no subscriptions', function (done) {
it('pub executes callback when unsubscribe is called and there are no subscriptions', (done) => {
pub.unsubscribe(helper.isDeepEqual([0, []]))
pub.get('foo', done)
})
})
describe('psubscribe', function () {
it('allows all channels to be subscribed to using a * pattern', function (done) {
var sub2 = redis.createClient({
describe('psubscribe', () => {
it('allows all channels to be subscribed to using a * pattern', (done) => {
const sub2 = redis.createClient({
returnBuffers: true
})
sub.subscribe('/foo', function () {
sub2.on('ready', function () {
sub.subscribe('/foo', () => {
sub2.on('ready', () => {
sub2.batch().psubscribe('*', helper.isDeepEqual([1, ['*']])).exec()
sub2.subscribe('/foo', function () {
sub2.subscribe('/foo', () => {
pub.pubsub('numsub', '/foo', helper.isDeepEqual(['/foo', 2]))
// sub2 is counted twice as it subscribed with psubscribe and subscribe
pub.publish('/foo', 'hello world', helper.isNumber(3))
})
sub2.on('pmessage', function (pattern, channel, message) {
sub2.on('pmessage', (pattern, channel, message) => {
assert.strictEqual(pattern.inspect(), Buffer.from('*').inspect())
assert.strictEqual(channel.inspect(), Buffer.from('/foo').inspect())
assert.strictEqual(message.inspect(), Buffer.from('hello world').inspect())
@@ -492,28 +492,28 @@ describe('publish/subscribe', function () {
})
})
it('allows to listen to pmessageBuffer and pmessage', function (done) {
var end = helper.callFuncAfter(done, 6)
var data = Array(10000).join('äüs^öéÉÉ`e')
sub.set('foo', data, function () {
it('allows to listen to pmessageBuffer and pmessage', (done) => {
const end = helper.callFuncAfter(done, 6)
const data = Array(10000).join('äüs^öéÉÉ`e')
sub.set('foo', data, () => {
sub.get('foo')
sub.stream.once('data', function () {
sub.stream.once('data', () => {
assert.strictEqual(sub.messageBuffers, false)
assert.strictEqual(sub.shouldBuffer, false)
sub.on('pmessageBuffer', function (pattern, channel, message) {
sub.on('pmessageBuffer', (pattern, channel, message) => {
assert.strictEqual(pattern.inspect(), Buffer.from('*').inspect())
assert.strictEqual(channel.inspect(), Buffer.from('/foo').inspect())
sub.quit(end)
})
assert.notStrictEqual(sub.messageBuffers, sub.buffers)
})
var batch = sub.batch()
const batch = sub.batch()
batch.psubscribe('*')
batch.subscribe('/foo')
batch.unsubscribe('/foo')
batch.unsubscribe(helper.isDeepEqual([1, []]))
batch.subscribe(['/foo'], helper.isDeepEqual([2, ['/foo']]))
batch.exec(function () {
batch.exec(() => {
// There's one subscriber to this channel
pub.pubsub('numsub', '/foo', helper.isDeepEqual(['/foo', 1], end))
// There's exactly one channel that is listened too
@@ -523,13 +523,13 @@ describe('publish/subscribe', function () {
pub.publish('/foo', 'hello world', helper.isNumber(2))
})
// Either messageBuffers or buffers has to be true, but not both at the same time
sub.on('pmessage', function (pattern, channel, message) {
sub.on('pmessage', (pattern, channel, message) => {
assert.strictEqual(pattern, '*')
assert.strictEqual(channel, '/foo')
assert.strictEqual(message, 'hello world')
end()
})
sub.on('message', function (channel, message) {
sub.on('message', (channel, message) => {
assert.strictEqual(channel, '/foo')
assert.strictEqual(message, 'hello world')
end()
@@ -538,26 +538,26 @@ describe('publish/subscribe', function () {
})
})
describe('punsubscribe', function () {
it('does not complain when punsubscribe is called and there are no subscriptions', function () {
describe('punsubscribe', () => {
it('does not complain when punsubscribe is called and there are no subscriptions', () => {
sub.punsubscribe()
})
it('executes callback when punsubscribe is called and there are no subscriptions', function (done) {
it('executes callback when punsubscribe is called and there are no subscriptions', (done) => {
pub.batch().punsubscribe(helper.isDeepEqual([0, []])).exec(done)
})
})
describe('fail for other commands while in pub sub mode', function () {
it('return error if only pub sub commands are allowed', function (done) {
describe('fail for other commands while in pub sub mode', () => {
it('return error if only pub sub commands are allowed', (done) => {
sub.subscribe('channel')
// Ping is allowed even if not listed as such!
sub.ping(function (err, res) {
sub.ping((err, res) => {
assert.strictEqual(err, null)
assert.strictEqual(res[0], 'pong')
})
// Get is forbidden
sub.get('foo', function (err, res) {
sub.get('foo', (err, res) => {
assert(/^ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message))
assert.strictEqual(err.command, 'GET')
})
@@ -565,9 +565,9 @@ describe('publish/subscribe', function () {
sub.quit(done)
})
it('emit error if only pub sub commands are allowed without callback', function (done) {
it('emit error if only pub sub commands are allowed without callback', (done) => {
sub.subscribe('channel')
sub.on('error', function (err) {
sub.on('error', (err) => {
assert(/^ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message))
assert.strictEqual(err.command, 'GET')
done()
@@ -576,23 +576,23 @@ describe('publish/subscribe', function () {
})
})
it('should not publish a message multiple times per command', function (done) {
var published = {}
it('should not publish a message multiple times per command', (done) => {
const published = {}
function subscribe (message) {
sub.removeAllListeners('subscribe')
sub.removeAllListeners('message')
sub.removeAllListeners('unsubscribe')
sub.on('subscribe', function () {
sub.on('subscribe', () => {
pub.publish('/foo', message)
})
sub.on('message', function (channel, message) {
sub.on('message', (channel, message) => {
if (published[message]) {
done(new Error('Message published more than once.'))
}
published[message] = true
})
sub.on('unsubscribe', function (channel, count) {
sub.on('unsubscribe', (channel, count) => {
assert.strictEqual(count, 0)
})
sub.subscribe('/foo')
@@ -600,38 +600,38 @@ describe('publish/subscribe', function () {
subscribe('hello')
setTimeout(function () {
setTimeout(() => {
sub.unsubscribe()
setTimeout(function () {
setTimeout(() => {
subscribe('world')
setTimeout(done, 50)
}, 40)
}, 40)
})
it('should not publish a message without any publish command', function (done) {
it('should not publish a message without any publish command', (done) => {
pub.set('foo', 'message')
pub.set('bar', 'hello')
pub.mget('foo', 'bar')
pub.subscribe('channel', function () {
pub.subscribe('channel', () => {
setTimeout(done, 50)
})
pub.on('message', function (msg) {
done(new Error('This message should not have been published: ' + msg))
pub.on('message', (msg) => {
done(new Error(`This message should not have been published: ${msg}`))
})
})
it('arguments variants', function (done) {
it('arguments variants', (done) => {
sub.batch()
.info(['stats'])
.info()
.client('KILL', ['type', 'pubsub'])
.client('KILL', ['type', 'pubsub'], function () {})
.client('KILL', ['type', 'pubsub'], () => {})
.unsubscribe()
.psubscribe(['pattern:*'])
.punsubscribe('unknown*')
.punsubscribe(['pattern:*'])
.exec(function (err, res) {
.exec((err, res) => {
if (err) throw err
sub.client('kill', ['type', 'pubsub'])
sub.psubscribe('*')
@@ -640,7 +640,7 @@ describe('publish/subscribe', function () {
})
})
afterEach(function () {
afterEach(() => {
// Explicitly ignore still running commands
pub.end(false)
sub.end(false)

50
test/rename.spec.js
View File

@@ -1,24 +1,24 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
// TODO: Fix redis process spawn on windows
if (process.platform !== 'win32') {
describe('rename commands', function () {
before(function (done) {
helper.stopRedis(function () {
describe('rename commands', () => {
before((done) => {
helper.stopRedis(() => {
helper.startRedis('./conf/rename.conf', done)
})
})
helper.allTests(function (ip, args) {
describe('using ' + ip, function () {
var client = null
helper.allTests((ip, args) => {
describe(`using ${ip}`, () => {
let client = null
beforeEach(function (done) {
beforeEach((done) => {
if (helper.redisProcess().spawnFailed()) return done()
client = redis.createClient({
renameCommands: {
@@ -27,12 +27,12 @@ if (process.platform !== 'win32') {
}
})
client.on('ready', function () {
client.on('ready', () => {
client.flushdb(done)
})
})
afterEach(function () {
afterEach(() => {
if (helper.redisProcess().spawnFailed()) return
client.end(true)
})
@@ -42,13 +42,13 @@ if (process.platform !== 'win32') {
client.set('key', 'value', helper.isString('OK'))
client.get('key', function (err, reply) {
client.get('key', (err, reply) => {
assert.strictEqual(err.message, 'ERR unknown command \'get\'')
assert.strictEqual(err.command, 'GET')
assert.strictEqual(reply, undefined)
})
client.getrange('key', 1, -1, function (err, reply) {
client.getrange('key', 1, -1, (err, reply) => {
assert.strictEqual(reply, 'alue')
assert.strictEqual(err, null)
done()
@@ -60,9 +60,9 @@ if (process.platform !== 'win32') {
client.batch([['set', 'key', 'value']]).exec(helper.isDeepEqual(['OK']))
var batch = client.batch()
const batch = client.batch()
batch.getrange('key', 1, -1)
batch.exec(function (err, res) {
batch.exec((err, res) => {
assert(!err)
assert.strictEqual(res.length, 1)
assert.strictEqual(res[0], 'alue')
@@ -75,9 +75,9 @@ if (process.platform !== 'win32') {
client.multi([['set', 'key', 'value']]).exec(helper.isDeepEqual(['OK']))
var multi = client.multi()
const multi = client.multi()
multi.getrange('key', 1, -1)
multi.exec(function (err, res) {
multi.exec((err, res) => {
assert(!err)
assert.strictEqual(res.length, 1)
assert.strictEqual(res[0], 'alue')
@@ -88,13 +88,13 @@ if (process.platform !== 'win32') {
it('should also work with multi and abort transaction', function (done) {
if (helper.redisProcess().spawnFailed()) this.skip()
var multi = client.multi()
const multi = client.multi()
multi.get('key')
multi.getrange('key', 1, -1, function (err, reply) {
multi.getrange('key', 1, -1, (err, reply) => {
assert.strictEqual(reply, 'alue')
assert.strictEqual(err, null)
})
multi.exec(function (err, res) {
multi.exec((err, res) => {
assert(err)
assert.strictEqual(err.message, 'EXECABORT Transaction discarded because of previous errors.')
assert.strictEqual(err.errors[0].message, 'ERR unknown command \'get\'')
@@ -116,7 +116,7 @@ if (process.platform !== 'win32') {
prefix: 'baz'
})
client.set('foo', 'bar')
client.keys('*', function (err, reply) {
client.keys('*', (err, reply) => {
assert.strictEqual(reply[0], 'bazfoo')
assert.strictEqual(err, null)
done()
@@ -125,9 +125,9 @@ if (process.platform !== 'win32') {
})
})
after(function (done) {
after((done) => {
if (helper.redisProcess().spawnFailed()) return done()
helper.stopRedis(function () {
helper.stopRedis(() => {
helper.startRedis('./conf/redis.conf', done)
})
})

140
test/return_buffers.spec.js
View File

@@ -1,37 +1,37 @@
'use strict'
var Buffer = require('safe-buffer').Buffer
var assert = require('assert')
var config = require('./lib/config')
var helper = require('./helper')
var redis = config.redis
const Buffer = require('safe-buffer').Buffer
const assert = require('assert')
const config = require('./lib/config')
const helper = require('./helper')
const redis = config.redis
describe('returnBuffers', function () {
helper.allTests(function (ip, basicArgs) {
describe('using ' + ip, function () {
var client
var args = config.configureClient(ip, {
describe('returnBuffers', () => {
helper.allTests((ip, basicArgs) => {
describe(`using ${ip}`, () => {
let client
const args = config.configureClient(ip, {
returnBuffers: true,
detectBuffers: true
})
beforeEach(function (done) {
beforeEach((done) => {
client = redis.createClient.apply(null, args)
var i = 1
let i = 1
if (args[2].detectBuffers) {
// Test if detectBuffer option was deactivated
assert.strictEqual(client.options.detectBuffers, false)
args[2].detectBuffers = false
i++
}
var end = helper.callFuncAfter(done, i)
client.on('warning', function (msg) {
const end = helper.callFuncAfter(done, i)
client.on('warning', (msg) => {
assert.strictEqual(msg, 'WARNING: You activated returnBuffers and detectBuffers at the same time. The return value is always going to be a buffer.')
end()
})
client.once('error', done)
client.once('connect', function () {
client.flushdb(function (err) {
client.once('connect', () => {
client.flushdb((err) => {
client.hmset('hash key 2', 'key 1', 'val 1', 'key 2', 'val 2')
client.set('string key 1', 'string value')
end(err)
@@ -39,18 +39,18 @@ describe('returnBuffers', function () {
})
})
describe('get', function () {
describe('first argument is a string', function () {
it('returns a buffer', function (done) {
client.get('string key 1', function (err, reply) {
describe('get', () => {
describe('first argument is a string', () => {
it('returns a buffer', (done) => {
client.get('string key 1', (err, reply) => {
assert.strictEqual(true, Buffer.isBuffer(reply))
assert.strictEqual('<Buffer 73 74 72 69 6e 67 20 76 61 6c 75 65>', reply.inspect())
return done(err)
})
})
it('returns a bufffer when executed as part of transaction', function (done) {
client.multi().get('string key 1').exec(function (err, reply) {
it('returns a bufffer when executed as part of transaction', (done) => {
client.multi().get('string key 1').exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual(true, Buffer.isBuffer(reply[0]))
assert.strictEqual('<Buffer 73 74 72 69 6e 67 20 76 61 6c 75 65>', reply[0].inspect())
@@ -60,14 +60,14 @@ describe('returnBuffers', function () {
})
})
describe('multi.hget', function () {
it('returns buffers', function (done) {
describe('multi.hget', () => {
it('returns buffers', (done) => {
client.multi()
.hget('hash key 2', 'key 1')
.hget(Buffer.from('hash key 2'), 'key 1')
.hget('hash key 2', Buffer.from('key 2'))
.hget('hash key 2', 'key 2')
.exec(function (err, reply) {
.exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(4, reply.length)
assert.strictEqual('<Buffer 76 61 6c 20 31>', reply[0].inspect())
@@ -82,14 +82,14 @@ describe('returnBuffers', function () {
})
})
describe('batch.hget', function () {
it('returns buffers', function (done) {
describe('batch.hget', () => {
it('returns buffers', (done) => {
client.batch()
.hget('hash key 2', 'key 1')
.hget(Buffer.from('hash key 2'), 'key 1')
.hget('hash key 2', Buffer.from('key 2'))
.hget('hash key 2', 'key 2')
.exec(function (err, reply) {
.exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(4, reply.length)
assert.strictEqual('<Buffer 76 61 6c 20 31>', reply[0].inspect())
@@ -104,10 +104,10 @@ describe('returnBuffers', function () {
})
})
describe('hmget', function () {
describe('first argument is a string', function () {
it('handles array of strings with undefined values in transaction (repro #344)', function (done) {
client.multi().hmget('hash key 2', 'key 3', 'key 4').exec(function (err, reply) {
describe('hmget', () => {
describe('first argument is a string', () => {
it('handles array of strings with undefined values in transaction (repro #344)', (done) => {
client.multi().hmget('hash key 2', 'key 3', 'key 4').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -118,9 +118,9 @@ describe('returnBuffers', function () {
})
})
describe('first argument is a buffer', function () {
it('returns buffers for keys requested', function (done) {
client.hmget(Buffer.from('hash key 2'), 'key 1', 'key 2', function (err, reply) {
describe('first argument is a buffer', () => {
it('returns buffers for keys requested', (done) => {
client.hmget(Buffer.from('hash key 2'), 'key 1', 'key 2', (err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(2, reply.length)
assert.strictEqual(true, Buffer.isBuffer(reply[0]))
@@ -131,8 +131,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffers for keys requested in transaction', function (done) {
client.multi().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec(function (err, reply) {
it('returns buffers for keys requested in transaction', (done) => {
client.multi().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -144,8 +144,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffers for keys requested in .batch', function (done) {
client.batch().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec(function (err, reply) {
it('returns buffers for keys requested in .batch', (done) => {
client.batch().hmget(Buffer.from('hash key 2'), 'key 1', 'key 2').exec((err, reply) => {
assert.strictEqual(true, Array.isArray(reply))
assert.strictEqual(1, reply.length)
assert.strictEqual(2, reply[0].length)
@@ -159,10 +159,10 @@ describe('returnBuffers', function () {
})
})
describe('hgetall', function (done) {
describe('first argument is a string', function () {
it('returns buffer values', function (done) {
client.hgetall('hash key 2', function (err, reply) {
describe('hgetall', (done) => {
describe('first argument is a string', () => {
it('returns buffer values', (done) => {
client.hgetall('hash key 2', (err, reply) => {
assert.strictEqual('object', typeof reply)
assert.strictEqual(2, Object.keys(reply).length)
assert.strictEqual('<Buffer 76 61 6c 20 31>', reply['key 1'].inspect())
@@ -171,8 +171,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffer values when executed in transaction', function (done) {
client.multi().hgetall('hash key 2').exec(function (err, reply) {
it('returns buffer values when executed in transaction', (done) => {
client.multi().hgetall('hash key 2').exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -182,8 +182,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffer values when executed in .batch', function (done) {
client.batch().hgetall('hash key 2').exec(function (err, reply) {
it('returns buffer values when executed in .batch', (done) => {
client.batch().hgetall('hash key 2').exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -194,9 +194,9 @@ describe('returnBuffers', function () {
})
})
describe('first argument is a buffer', function () {
it('returns buffer values', function (done) {
client.hgetall(Buffer.from('hash key 2'), function (err, reply) {
describe('first argument is a buffer', () => {
it('returns buffer values', (done) => {
client.hgetall(Buffer.from('hash key 2'), (err, reply) => {
assert.strictEqual(null, err)
assert.strictEqual('object', typeof reply)
assert.strictEqual(2, Object.keys(reply).length)
@@ -208,8 +208,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffer values when executed in transaction', function (done) {
client.multi().hgetall(Buffer.from('hash key 2')).exec(function (err, reply) {
it('returns buffer values when executed in transaction', (done) => {
client.multi().hgetall(Buffer.from('hash key 2')).exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -221,8 +221,8 @@ describe('returnBuffers', function () {
})
})
it('returns buffer values when executed in .batch', function (done) {
client.batch().hgetall(Buffer.from('hash key 2')).exec(function (err, reply) {
it('returns buffer values when executed in .batch', (done) => {
client.batch().hgetall(Buffer.from('hash key 2')).exec((err, reply) => {
assert.strictEqual(1, reply.length)
assert.strictEqual('object', typeof reply[0])
assert.strictEqual(2, Object.keys(reply[0]).length)
@@ -236,31 +236,31 @@ describe('returnBuffers', function () {
})
})
describe('publish/subscribe', function (done) {
var pub
var sub
var channel = 'test channel'
var message = Buffer.from('test message')
describe('publish/subscribe', (done) => {
let pub
let sub
const channel = 'test channel'
const message = Buffer.from('test message')
var args = config.configureClient(ip, {
const args = config.configureClient(ip, {
returnBuffers: true
})
beforeEach(function (done) {
var pubConnected
var subConnected
beforeEach((done) => {
let pubConnected
let subConnected
pub = redis.createClient.apply(redis.createClient, basicArgs)
sub = redis.createClient.apply(null, args)
pub.once('connect', function () {
pub.flushdb(function () {
pub.once('connect', () => {
pub.flushdb(() => {
pubConnected = true
if (subConnected) {
done()
}
})
})
sub.once('connect', function () {
sub.once('connect', () => {
subConnected = true
if (pubConnected) {
done()
@@ -268,12 +268,12 @@ describe('returnBuffers', function () {
})
})
it('receives buffer messages', function (done) {
sub.on('subscribe', function (chnl, count) {
it('receives buffer messages', (done) => {
sub.on('subscribe', (chnl, count) => {
pub.publish(channel, message)
})
sub.on('message', function (chnl, msg) {
sub.on('message', (chnl, msg) => {
assert.strictEqual(true, Buffer.isBuffer(msg))
assert.strictEqual('<Buffer 74 65 73 74 20 6d 65 73 73 61 67 65>', msg.inspect())
return done()
@@ -282,7 +282,7 @@ describe('returnBuffers', function () {
sub.subscribe(channel)
})
afterEach(function () {
afterEach(() => {
sub.end(true)
pub.end(true)
})

64
test/tls.spec.js
View File

@@ -1,28 +1,28 @@
'use strict'
var assert = require('assert')
var config = require('./lib/config')
var fs = require('fs')
var helper = require('./helper')
var path = require('path')
var redis = config.redis
var utils = require('../lib/utils')
const assert = require('assert')
const config = require('./lib/config')
const fs = require('fs')
const helper = require('./helper')
const path = require('path')
const redis = config.redis
const utils = require('../lib/utils')
var tlsOptions = {
const tlsOptions = {
servername: 'redis.js.org',
rejectUnauthorized: true,
ca: [ String(fs.readFileSync(path.resolve(__dirname, './conf/redis.js.org.cert'))) ]
}
var tlsPort = 6380
const tlsPort = 6380
// Use skip instead of returning to indicate what tests really got skipped
var skip = false
let skip = false
// Wait until stunnel4 is in the travis whitelist
// Check: https://github.com/travis-ci/apt-package-whitelist/issues/403
// If this is merged, remove the travis env checks
describe.skip('TLS connection tests', function () {
before(function (done) {
describe.skip('TLS connection tests', () => {
before((done) => {
// Print the warning when the tests run instead of while starting mocha
if (process.platform === 'win32') {
skip = true
@@ -32,46 +32,46 @@ describe.skip('TLS connection tests', function () {
console.warn('\nTravis does not support stunnel right now. Skipping tests.\nCheck: https://github.com/travis-ci/apt-package-whitelist/issues/403\n')
}
if (skip) return done()
helper.stopStunnel(function () {
helper.stopStunnel(() => {
helper.startStunnel(done)
})
})
after(function (done) {
after((done) => {
if (skip) return done()
helper.stopStunnel(done)
})
var client
let client
afterEach(function () {
afterEach(() => {
if (skip) return
client.end(true)
})
describe('on lost connection', function () {
describe('on lost connection', () => {
it.skip('emit an error after max retry timeout and do not try to reconnect afterwards', function (done) {
if (skip) this.skip()
var connectTimeout = 500 // in ms
const connectTimeout = 500 // in ms
client = redis.createClient({
connectTimeout: connectTimeout,
connectTimeout,
port: tlsPort,
tls: tlsOptions
})
var time = 0
assert.strictEqual(client.address, '127.0.0.1:' + tlsPort)
let time = 0
assert.strictEqual(client.address, `127.0.0.1:${tlsPort}`)
client.once('ready', function () {
client.once('ready', () => {
helper.killConnection(client)
})
client.on('reconnecting', function (params) {
client.on('reconnecting', (params) => {
time += params.delay
})
client.on('error', function (err) {
client.on('error', (err) => {
if (/Redis connection in broken state: connection timeout.*?exceeded./.test(err.message)) {
process.nextTick(function () {
process.nextTick(() => {
assert.strictEqual(time, connectTimeout)
assert.strictEqual(client.emittedEnd, true)
assert.strictEqual(client.connected, false)
@@ -85,21 +85,21 @@ describe.skip('TLS connection tests', function () {
})
})
describe('when not connected', function () {
describe('when not connected', () => {
it('connect with host and port provided in the tls object', function (done) {
if (skip) this.skip()
var tls = utils.clone(tlsOptions)
const tls = utils.clone(tlsOptions)
tls.port = tlsPort
tls.host = 'localhost'
client = redis.createClient({
connectTimeout: 1000,
tls: tls
tls
})
// verify connection is using TCP, not UNIX socket
assert.strictEqual(client.connectionOptions.host, 'localhost')
assert.strictEqual(client.connectionOptions.port, tlsPort)
assert.strictEqual(client.address, 'localhost:' + tlsPort)
assert.strictEqual(client.address, `localhost:${tlsPort}`)
assert(client.stream.encrypted)
client.set('foo', 'bar')
@@ -108,7 +108,7 @@ describe.skip('TLS connection tests', function () {
it('fails to connect because the cert is not correct', function (done) {
if (skip) this.skip()
var faultyCert = utils.clone(tlsOptions)
const faultyCert = utils.clone(tlsOptions)
faultyCert.ca = [ String(fs.readFileSync(path.resolve(__dirname, './conf/faulty.cert'))) ]
client = redis.createClient({
host: 'localhost',
@@ -116,8 +116,8 @@ describe.skip('TLS connection tests', function () {
port: tlsPort,
tls: faultyCert
})
assert.strictEqual(client.address, 'localhost:' + tlsPort)
client.on('error', function (err) {
assert.strictEqual(client.address, `localhost:${tlsPort}`)
client.on('error', (err) => {
assert(/DEPTH_ZERO_SELF_SIGNED_CERT/.test(err.code || err.message), err)
client.end(true)
})

114
test/unify_options.spec.js
View File

@@ -1,15 +1,15 @@
'use strict'
var assert = require('assert')
var unifyOptions = require('../lib/createClient')
var intercept = require('intercept-stdout')
const assert = require('assert')
const unifyOptions = require('../lib/createClient')
const intercept = require('intercept-stdout')
describe('createClient options', function () {
describe('port as first parameter', function () {
it('pass the options in the second parameter after a port', function () {
var options = unifyOptions(1234, {
describe('createClient options', () => {
describe('port as first parameter', () => {
it('pass the options in the second parameter after a port', () => {
const options = unifyOptions(1234, {
option1: true,
option2: function () {}
option2 () {}
})
assert.strictEqual(Object.keys(options).length, 4)
assert(options.option1)
@@ -18,10 +18,10 @@ describe('createClient options', function () {
assert.strictEqual(typeof options.option2, 'function')
})
it('pass the options in the third parameter after a port and host being set to null', function () {
var options = unifyOptions(1234, null, {
it('pass the options in the third parameter after a port and host being set to null', () => {
const options = unifyOptions(1234, null, {
option1: true,
option2: function () {}
option2 () {}
})
assert.strictEqual(Object.keys(options).length, 4)
assert(options.option1)
@@ -30,10 +30,10 @@ describe('createClient options', function () {
assert.strictEqual(typeof options.option2, 'function')
})
it('pass the options in the third parameter after a port and host being set to undefined', function () {
var options = unifyOptions(1234, undefined, {
it('pass the options in the third parameter after a port and host being set to undefined', () => {
const options = unifyOptions(1234, undefined, {
option1: true,
option2: function () {}
option2 () {}
})
assert.strictEqual(Object.keys(options).length, 4)
assert(options.option1)
@@ -42,10 +42,10 @@ describe('createClient options', function () {
assert.strictEqual(typeof options.option2, 'function')
})
it('pass the options in the third parameter after a port and host', function () {
var options = unifyOptions('1234', 'localhost', {
it('pass the options in the third parameter after a port and host', () => {
const options = unifyOptions('1234', 'localhost', {
option1: true,
option2: function () {}
option2 () {}
})
assert.strictEqual(Object.keys(options).length, 4)
assert(options.option1)
@@ -54,7 +54,7 @@ describe('createClient options', function () {
assert.strictEqual(typeof options.option2, 'function')
})
it('should throw with three parameters all set to a truthy value', function () {
it('should throw with three parameters all set to a truthy value', () => {
try {
unifyOptions(1234, {}, {})
throw new Error('failed')
@@ -64,11 +64,11 @@ describe('createClient options', function () {
})
})
describe('unix socket as first parameter', function () {
it('pass the options in the second parameter after a port', function () {
var options = unifyOptions('/tmp/redis.sock', {
describe('unix socket as first parameter', () => {
it('pass the options in the second parameter after a port', () => {
const options = unifyOptions('/tmp/redis.sock', {
option1: true,
option2: function () {},
option2 () {},
option3: [1, 2, 3]
})
assert.strictEqual(Object.keys(options).length, 4)
@@ -78,10 +78,10 @@ describe('createClient options', function () {
assert.strictEqual(options.option3.length, 3)
})
it('pass the options in the third parameter after a port and host being set to null', function () {
var options = unifyOptions('/tmp/redis.sock', null, {
it('pass the options in the third parameter after a port and host being set to null', () => {
const options = unifyOptions('/tmp/redis.sock', null, {
option1: true,
option2: function () {}
option2 () {}
})
assert.strictEqual(Object.keys(options).length, 3)
assert(options.option1)
@@ -90,17 +90,17 @@ describe('createClient options', function () {
})
})
describe('redis url as first parameter', function () {
it('empty redis url including options as second parameter', function () {
var options = unifyOptions('redis://', {
describe('redis url as first parameter', () => {
it('empty redis url including options as second parameter', () => {
const options = unifyOptions('redis://', {
option: [1, 2, 3]
})
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.option.length, 3)
})
it('begin with two slashes including options as third parameter', function () {
var options = unifyOptions('//:abc@/3?port=123', {
it('begin with two slashes including options as third parameter', () => {
const options = unifyOptions('//:abc@/3?port=123', {
option: [1, 2, 3]
})
assert.strictEqual(Object.keys(options).length, 4)
@@ -110,13 +110,13 @@ describe('createClient options', function () {
assert.strictEqual(options.password, 'abc')
})
it('duplicated, identical query options including options obj', function () {
var text = ''
var unhookIntercept = intercept(function (data) {
it('duplicated, identical query options including options obj', () => {
let text = ''
const unhookIntercept = intercept((data) => {
text += data
return ''
})
var options = unifyOptions('//:abc@localhost:123/3?db=3&port=123&password=abc', null, {
const options = unifyOptions('//:abc@localhost:123/3?db=3&port=123&password=abc', null, {
option: [1, 2, 3]
})
unhookIntercept()
@@ -133,7 +133,7 @@ describe('createClient options', function () {
assert.strictEqual(options.password, 'abc')
})
it('should throw on duplicated, non-identical query options', function () {
it('should throw on duplicated, non-identical query options', () => {
try {
unifyOptions('//:abc@localhost:1234/3?port=123&password=abc')
throw new Error('failed')
@@ -142,7 +142,7 @@ describe('createClient options', function () {
}
})
it('should throw without protocol slashes', function () {
it('should throw without protocol slashes', () => {
try {
unifyOptions('redis:abc@localhost:123/3?db=3&port=123&password=abc')
throw new Error('failed')
@@ -151,13 +151,13 @@ describe('createClient options', function () {
}
})
it('warns on protocol other than redis in the redis url', function () {
var text = ''
var unhookIntercept = intercept(function (data) {
it('warns on protocol other than redis in the redis url', () => {
let text = ''
const unhookIntercept = intercept((data) => {
text += data
return ''
})
var options = unifyOptions('http://abc')
const options = unifyOptions('http://abc')
unhookIntercept()
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.host, 'abc')
@@ -165,29 +165,29 @@ describe('createClient options', function () {
})
})
describe('no parameters or set to null / undefined', function () {
it('no parameters', function () {
var options = unifyOptions()
describe('no parameters or set to null / undefined', () => {
it('no parameters', () => {
const options = unifyOptions()
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.host, undefined)
})
it('set to null', function () {
var options = unifyOptions(null, null)
it('set to null', () => {
const options = unifyOptions(null, null)
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.host, null)
})
it('set to undefined', function () {
var options = unifyOptions(undefined, undefined)
it('set to undefined', () => {
const options = unifyOptions(undefined, undefined)
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.host, undefined)
})
})
describe('only an options object is passed', function () {
it('with options', function () {
var options = unifyOptions({
describe('only an options object is passed', () => {
it('with options', () => {
const options = unifyOptions({
option: true
})
assert.strictEqual(Object.keys(options).length, 2)
@@ -195,13 +195,13 @@ describe('createClient options', function () {
assert.strictEqual(options.option, true)
})
it('without options', function () {
var options = unifyOptions({})
it('without options', () => {
const options = unifyOptions({})
assert.strictEqual(Object.keys(options).length, 1)
assert.strictEqual(options.host, undefined)
})
it('should throw with more parameters', function () {
it('should throw with more parameters', () => {
try {
unifyOptions({
option: true
@@ -212,8 +212,8 @@ describe('createClient options', function () {
}
})
it('including url as option', function () {
var options = unifyOptions({
it('including url as option', () => {
const options = unifyOptions({
option: [1, 2, 3],
url: '//hm:abc@localhost:123/3'
})
@@ -227,8 +227,8 @@ describe('createClient options', function () {
})
})
describe('faulty data', function () {
it('throws on strange connection info', function () {
describe('faulty data', () => {
it('throws on strange connection info', () => {
try {
unifyOptions(true)
throw new Error('failed')

68
test/utils.spec.js
View File

@@ -1,35 +1,35 @@
'use strict'
var assert = require('assert')
var Queue = require('double-ended-queue')
var utils = require('../lib/utils')
const assert = require('assert')
const Queue = require('double-ended-queue')
const utils = require('../lib/utils')
describe('utils.js', function () {
describe('clone', function () {
it('ignore the object prototype and clone a nested array / object', function () {
var obj = {
describe('utils.js', () => {
describe('clone', () => {
it('ignore the object prototype and clone a nested array / object', () => {
const obj = {
a: [null, 'foo', ['bar'], {
'i\'m special': true
}],
number: 5,
fn: function noop () {}
}
var clone = utils.clone(obj)
const clone = utils.clone(obj)
assert.deepEqual(clone, obj)
assert.strictEqual(obj.fn, clone.fn)
assert(typeof clone.fn === 'function')
})
it('replace falsy values with an empty object as return value', function () {
var a = utils.clone()
var b = utils.clone(null)
it('replace falsy values with an empty object as return value', () => {
const a = utils.clone()
const b = utils.clone(null)
assert.strictEqual(Object.keys(a).length, 0)
assert.strictEqual(Object.keys(b).length, 0)
})
it('throws on circular data', function () {
it('throws on circular data', () => {
try {
var a = {}
const a = {}
a.b = a
utils.clone(a)
throw new Error('failed')
@@ -39,25 +39,25 @@ describe('utils.js', function () {
})
})
describe('replyInOrder', function () {
var errCount = 0
var resCount = 0
var emitted = false
var clientMock = {
emit: function () { emitted = true },
describe('replyInOrder', () => {
let errCount = 0
let resCount = 0
let emitted = false
const clientMock = {
emit () { emitted = true },
offlineQueue: new Queue(),
commandQueue: new Queue()
}
var createCommandObj = function () {
const createCommandObj = function () {
return {
callback: function (err, res) {
callback (err, res) {
if (err) errCount++
else resCount++
}
}
}
beforeEach(function () {
beforeEach(() => {
clientMock.offlineQueue.clear()
clientMock.commandQueue.clear()
errCount = 0
@@ -65,28 +65,28 @@ describe('utils.js', function () {
emitted = false
})
it('no elements in either queue. Reply in the next tick with callback', function (done) {
var called = false
utils.replyInOrder(clientMock, function () {
it('no elements in either queue. Reply in the next tick with callback', (done) => {
let called = false
utils.replyInOrder(clientMock, () => {
called = true
done()
}, null, null)
assert(!called)
})
it('no elements in either queue. Reply in the next tick without callback', function (done) {
it('no elements in either queue. Reply in the next tick without callback', (done) => {
assert(!emitted)
utils.replyInOrder(clientMock, null, new Error('tada'))
assert(!emitted)
setTimeout(function () {
setTimeout(() => {
assert(emitted)
done()
}, 1)
})
it('elements in the offline queue. Reply after the offline queue is empty and respect the commandObj callback', function (done) {
it('elements in the offline queue. Reply after the offline queue is empty and respect the commandObj callback', (done) => {
clientMock.offlineQueue.push(createCommandObj(), createCommandObj())
utils.replyInOrder(clientMock, function () {
utils.replyInOrder(clientMock, () => {
assert.strictEqual(clientMock.offlineQueue.length, 0)
assert.strictEqual(resCount, 2)
done()
@@ -94,9 +94,9 @@ describe('utils.js', function () {
while (clientMock.offlineQueue.length) clientMock.offlineQueue.shift().callback(null, 'foo')
})
it('elements in the offline queue. Reply after the offline queue is empty and respect the commandObj error emit', function (done) {
it('elements in the offline queue. Reply after the offline queue is empty and respect the commandObj error emit', (done) => {
clientMock.commandQueue.push({}, createCommandObj(), {})
utils.replyInOrder(clientMock, function () {
utils.replyInOrder(clientMock, () => {
assert.strictEqual(clientMock.commandQueue.length, 0)
assert(emitted)
assert.strictEqual(errCount, 1)
@@ -104,17 +104,17 @@ describe('utils.js', function () {
done()
}, null, null)
while (clientMock.commandQueue.length) {
var commandObj = clientMock.commandQueue.shift()
const commandObj = clientMock.commandQueue.shift()
if (commandObj.callback) {
commandObj.callback(new Error('tada'))
}
}
})
it('elements in the offline queue and the commandQueue. Reply all other commands got handled respect the commandObj', function (done) {
it('elements in the offline queue and the commandQueue. Reply all other commands got handled respect the commandObj', (done) => {
clientMock.commandQueue.push(createCommandObj(), createCommandObj())
clientMock.offlineQueue.push(createCommandObj(), {})
utils.replyInOrder(clientMock, function (err, res) {
utils.replyInOrder(clientMock, (err, res) => {
if (err) throw err
assert.strictEqual(clientMock.commandQueue.length, 0)
assert.strictEqual(clientMock.offlineQueue.length, 0)