Socket
Socket
Sign inDemoInstall

catbox-redis

Package Overview
Dependencies
Maintainers
5
Versions
28
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

catbox-redis - npm Package Compare versions

Comparing version 3.1.1 to 4.0.0

160

lib/index.js

@@ -31,49 +31,49 @@

internals.Connection.prototype.start = function (callback) {
// Async
internals.Connection.prototype.start = function () {
callback = Hoek.once(callback);
// Return a promise that is resolved when everything is ready
return new Promise((resolve, reject) => {
const self = this;
if (this.client) {
return Hoek.nextTick(callback)();
}
if (this.client) {
return resolve();
}
let client;
let client;
const options = {
password: this.settings.password,
db: this.settings.database || this.settings.db
};
const options = {
password: this.settings.password,
db: this.settings.database || this.settings.db
};
if (this.settings.sentinels && this.settings.sentinels.length) {
options.sentinels = this.settings.sentinels;
options.name = this.settings.sentinelName;
client = Redis.createClient(options);
}
else if (this.settings.url) {
client = Redis.createClient(this.settings.url, options);
}
else if (this.settings.socket) {
client = Redis.createClient(this.settings.socket, options);
}
else {
client = Redis.createClient(this.settings.port, this.settings.host, options);
}
if (this.settings.sentinels && this.settings.sentinels.length) {
options.sentinels = this.settings.sentinels;
options.name = this.settings.sentinelName;
client = Redis.createClient(options);
}
else if (this.settings.url) {
client = Redis.createClient(this.settings.url, options);
}
else if (this.settings.socket) {
client = Redis.createClient(this.settings.socket, options);
}
else {
client = Redis.createClient(this.settings.port, this.settings.host, options);
}
// Listen to errors
// Listen to errors
client.on('error', (err) => {
client.on('error', (err) => {
if (!this.client) { // Failed to connect
client.end(false);
return reject(err);
}
});
if (!self.client) { // Failed to connect
client.end(false);
return callback(err);
}
});
// Wait for connection
client.once('ready', () => {
// Wait for connection
client.once('ready', () => {
self.client = client;
return callback();
this.client = client;
return resolve();
});
});

@@ -113,45 +113,38 @@ };

internals.Connection.prototype.get = function (key, callback) {
internals.Connection.prototype.get = async function (key) {
if (!this.client) {
return callback(new Error('Connection not started'));
throw Error('Connection not started');
}
this.client.get(this.generateKey(key), (err, result) => {
const result = await this.client.get(this.generateKey(key));
if (err) {
return callback(err);
}
if (!result) {
return null;
}
if (!result) {
return callback(null, null);
}
let envelope = null;
try {
envelope = JSON.parse(result);
}
catch (err) { } // Handled by validation below
let envelope = null;
try {
envelope = JSON.parse(result);
}
catch (err) { } // Handled by validation below
if (!envelope) {
throw Error('Bad envelope content');
}
if (!envelope) {
return callback(new Error('Bad envelope content'));
}
if ((!envelope.item && envelope.item !== 0) ||
!envelope.stored) {
if (!envelope.item ||
!envelope.stored) {
throw Error('Incorrect envelope structure');
}
return callback(new Error('Incorrect envelope structure'));
}
return callback(null, envelope);
});
return envelope;
};
internals.Connection.prototype.set = function (key, value, ttl, callback) {
internals.Connection.prototype.set = async function (key, value, ttl) {
const self = this;
if (!this.client) {
return callback(new Error('Connection not started'));
throw Error('Connection not started');
}

@@ -167,36 +160,19 @@

let stringifiedEnvelope = null;
const stringifiedEnvelope = JSON.stringify(envelope);
try {
stringifiedEnvelope = JSON.stringify(envelope);
}
catch (err) {
return callback(err);
}
await this.client.set(cacheKey, stringifiedEnvelope);
this.client.set(cacheKey, stringifiedEnvelope, (err) => {
if (err) {
return callback(err);
}
const ttlSec = Math.max(1, Math.floor(ttl / 1000));
self.client.expire(cacheKey, ttlSec, (err) => { // Use 'pexpire' with ttl in Redis 2.6.0
return callback(err);
});
});
const ttlSec = Math.max(1, Math.floor(ttl / 1000));
// Use 'pexpire' with ttl in Redis 2.6.0
return this.client.expire(cacheKey, ttlSec);
};
internals.Connection.prototype.drop = function (key, callback) {
// Async
internals.Connection.prototype.drop = function (key) {
if (!this.client) {
return callback(new Error('Connection not started'));
throw Error('Connection not started');
}
this.client.del(this.generateKey(key), (err) => {
return callback(err);
});
return this.client.del(this.generateKey(key));
};

@@ -203,0 +179,0 @@

12

package.json
{
"name": "catbox-redis",
"description": "Redis adapter for catbox",
"version": "3.1.1",
"version": "4.0.0",
"author": "Eran Hammer <eran@hammer.io> (http://hueniverse.com)",

@@ -17,12 +17,12 @@ "contributors": [

"engines": {
"node": ">=4.0.0"
"node": ">=8.0.0"
},
"dependencies": {
"hoek": "4.x.x",
"hoek": "5.x.x",
"ioredis": "3.x.x"
},
"devDependencies": {
"catbox": "7.x.x",
"code": "4.x.x",
"lab": "13.x.x"
"catbox": "10.x.x",
"code": "5.x.x",
"lab": "15.x.x"
},

@@ -29,0 +29,0 @@ "scripts": {

704

test/index.js

@@ -29,5 +29,16 @@

// Utils
const timeoutPromise = (timer) => {
return new Promise((resolve) => {
setTimeout(resolve, timer);
});
};
describe('Redis', () => {
it('throws an error if not created with new', (done) => {
it('throws an error if not created with new', () => {

@@ -40,57 +51,50 @@ const fn = () => {

expect(fn).to.throw(Error);
done();
});
it('creates a new connection', (done) => {
it('creates a new connection', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
expect(client.isReady()).to.equal(true);
done(err);
});
await client.start();
expect(client.isReady()).to.equal(true);
});
it('closes the connection', (done) => {
it('closes the connection', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
expect(err).to.not.exist();
expect(client.isReady()).to.equal(true);
client.stop();
expect(client.isReady()).to.equal(false);
done();
});
await client.start();
expect(client.isReady()).to.equal(true);
client.stop();
expect(client.isReady()).to.equal(false);
});
it('allow passing client in option', (done) => {
it('allow passing client in option', () => {
const redisClient = RedisClient.createClient();
return new Promise((resolve, reject) => {
let getCalled = false;
const _get = redisClient.get;
redisClient.get = function (key, callback) {
const redisClient = RedisClient.createClient();
getCalled = true;
return _get.apply(redisClient, arguments);
};
let getCalled = false;
const _get = redisClient.get;
redisClient.get = function (key, callback) {
redisClient.on('error', done);
redisClient.once('ready', () => {
getCalled = true;
return _get.apply(redisClient, arguments);
};
const client = new Catbox.Client(Redis, {
client: redisClient
redisClient.on('error', (err) => {
reject(err);
});
client.start((err) => {
redisClient.once('ready', async () => {
expect(err).to.not.exist();
const client = new Catbox.Client(Redis, {
client: redisClient
});
await client.start();
expect(client.isReady()).to.equal(true);
const key = { id: 'x', segment: 'test' };
client.get(key, (err, result) => {
await client.get(key);
expect(getCalled).to.equal(true);
expect(err).to.equal(null);
expect(getCalled).to.equal(true);
done();
});
resolve();
});

@@ -100,238 +104,183 @@ });

it('gets an item after setting it', (done) => {
it('gets an item after setting it', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
const key = { id: 'x', segment: 'test' };
client.set(key, '123', 500, (err) => {
const key = { id: 'x', segment: 'test' };
await client.set(key, '123', 500);
expect(err).to.not.exist();
client.get(key, (err, result) => {
expect(err).to.equal(null);
expect(result.item).to.equal('123');
done();
});
});
});
const result = await client.get(key);
expect(result.item).to.equal('123');
});
it('fails setting an item circular references', (done) => {
it('fails setting an item circular references', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
const key = { id: 'x', segment: 'test' };
const value = { a: 1 };
value.b = value;
expect(err).to.not.exist();
const key = { id: 'x', segment: 'test' };
const value = { a: 1 };
value.b = value;
client.set(key, value, 10, (err) => {
await expect((() => {
expect(err.message).to.equal('Converting circular structure to JSON');
done();
});
});
return client.set(key, value, 10);
})()).to.reject(Error, 'Converting circular structure to JSON');
});
it('ignored starting a connection twice on same event', (done) => {
it('ignored starting a connection twice on same event', () => {
const client = new Catbox.Client(Redis);
let x = 2;
const start = () => {
return new Promise((resolve, reject) => {
client.start((err) => {
const client = new Catbox.Client(Redis);
let x = 2;
const start = async () => {
expect(err).to.not.exist();
await client.start();
expect(client.isReady()).to.equal(true);
--x;
if (!x) {
done();
resolve();
}
});
};
};
start();
start();
start();
start();
});
});
it('ignored starting a connection twice chained', (done) => {
it('ignored starting a connection twice chained', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
expect(err).to.not.exist();
expect(client.isReady()).to.equal(true);
await client.start();
expect(client.isReady()).to.equal(true);
client.start((err) => {
expect(err).to.not.exist();
expect(client.isReady()).to.equal(true);
done();
});
});
await client.start();
expect(client.isReady()).to.equal(true);
});
it('returns not found on get when using null key', (done) => {
it('returns not found on get when using null key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.get(null, (err, result) => {
const result = await client.get(null);
expect(err).to.equal(null);
expect(result).to.equal(null);
done();
});
});
expect(result).to.equal(null);
});
it('returns not found on get when item expired', (done) => {
it('returns not found on get when item expired', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
const key = { id: 'x', segment: 'test' };
client.set(key, 'x', 1, (err) => {
const key = { id: 'x', segment: 'test' };
await client.set(key, 'x', 1);
expect(err).to.not.exist();
setTimeout(() => {
client.get(key, (err, result) => {
expect(err).to.equal(null);
expect(result).to.equal(null);
done();
});
}, 2);
});
});
await timeoutPromise(2);
const result = await client.get(key);
expect(result).to.equal(null);
});
it('returns error on set when using null key', (done) => {
it('returns error on set when using null key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.set(null, {}, 1000, (err) => {
await expect((() => {
expect(err instanceof Error).to.equal(true);
done();
});
});
return client.set(null, {}, 1000);
})()).to.reject(Error);
});
it('returns error on get when using invalid key', (done) => {
it('returns error on get when using invalid key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.get({}, (err) => {
await expect((() => {
expect(err instanceof Error).to.equal(true);
done();
});
});
return client.get({});
})()).to.reject(Error);
});
it('returns error on drop when using invalid key', (done) => {
it('returns error on drop when using invalid key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.drop({}, (err) => {
await expect((() => {
expect(err instanceof Error).to.equal(true);
done();
});
});
return client.drop({});
})()).to.reject(Error);
});
it('returns error on set when using invalid key', (done) => {
it('returns error on set when using invalid key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.set({}, {}, 1000, (err) => {
await expect((() => {
expect(err instanceof Error).to.equal(true);
done();
});
});
return client.set({}, {}, 1000);
})()).to.reject(Error);
});
it('ignores set when using non-positive ttl value', (done) => {
it('ignores set when using non-positive ttl value', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
expect(err).to.not.exist();
const key = { id: 'x', segment: 'test' };
client.set(key, 'y', 0, (err) => {
expect(err).to.not.exist();
done();
});
});
await client.start();
const key = { id: 'x', segment: 'test' };
await client.set(key, 'y', 0);
});
it('returns error on drop when using null key', (done) => {
it('returns error on drop when using null key', async () => {
const client = new Catbox.Client(Redis);
client.start((err) => {
await client.start();
expect(err).to.not.exist();
client.drop(null, (err) => {
await expect((() => {
expect(err instanceof Error).to.equal(true);
done();
});
});
return client.drop(null);
})()).to.reject(Error);
});
it('returns error on get when stopped', (done) => {
it('returns error on get when stopped', async () => {
const client = new Catbox.Client(Redis);
client.stop();
const key = { id: 'x', segment: 'test' };
client.connection.get(key, (err, result) => {
await expect((() => {
expect(err).to.exist();
expect(result).to.not.exist();
done();
});
return client.connection.get(key);
})()).to.reject(Error, 'Connection not started');
});
it('returns error on set when stopped', (done) => {
it('returns error on set when stopped', async () => {
const client = new Catbox.Client(Redis);
client.stop();
const key = { id: 'x', segment: 'test' };
client.connection.set(key, 'y', 1, (err) => {
await expect((() => {
expect(err).to.exist();
done();
});
return client.connection.set(key, 'y', 1);
})()).to.reject(Error, 'Connection not started');
});
it('returns error on drop when stopped', (done) => {
it('returns error on drop when stopped', async () => {
const client = new Catbox.Client(Redis);
client.stop();
const key = { id: 'x', segment: 'test' };
client.connection.drop(key, (err) => {
await expect((async () => {
expect(err).to.exist();
done();
});
await client.connection.drop(key);
})()).to.reject(Error, 'Connection not started');
});
it('returns error on missing segment name', (done) => {
it('returns error on missing segment name', () => {

@@ -347,6 +296,5 @@ const config = {

expect(fn).to.throw(Error);
done();
});
it('returns error on bad segment name', (done) => {
it('returns error on bad segment name', () => {

@@ -362,14 +310,13 @@ const config = {

expect(fn).to.throw(Error);
done();
});
it('returns error when cache item dropped while stopped', (done) => {
it('returns error when cache item dropped while stopped', async () => {
const client = new Catbox.Client(Redis);
client.stop();
client.drop('a', (err) => {
expect(err).to.exist();
done();
});
await expect((() => {
return client.drop('a');
})()).to.reject(Error);
});

@@ -379,3 +326,3 @@

it('sets client to when the connection succeeds', (done) => {
it('sets client to when the connection succeeds', async () => {

@@ -389,11 +336,7 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
expect(redis.client).to.exist();
done();
});
await redis.start();
expect(redis.client).to.exist();
});
it('reuses the client when a connection is already started', (done) => {
it('reuses the client when a connection is already started', async () => {

@@ -407,16 +350,10 @@ const options = {

redis.start((err) => {
await redis.start();
const client = redis.client;
expect(err).to.not.exist();
const client = redis.client;
redis.start(() => {
expect(client).to.equal(redis.client);
done();
});
});
await redis.start();
expect(client).to.equal(redis.client);
});
it('returns an error when connection fails', (done) => {
it('returns an error when connection fails', async () => {

@@ -430,12 +367,11 @@ const options = {

redis.start((err) => {
await expect((() => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
expect(redis.client).to.not.exist();
done();
});
return redis.start();
})()).to.reject(Error);
expect(redis.client).to.not.exist();
});
it('sends auth command when password is provided', (done) => {
it('sends auth command when password is provided', async () => {

@@ -450,17 +386,16 @@ const options = {

const log = console.log;
console.log = function (message) {
const warn = console.warn;
let consoleMessage = '';
console.warn = function (message) {
expect(message).to.contain('Warning');
console.log = log;
consoleMessage += message;
};
redis.start((err) => {
await redis.start();
expect(err).to.not.exist();
done();
});
console.warn = warn;
expect(consoleMessage).to.contain('Redis server does not require a password, but a password was supplied.');
});
it('fails in error when auth is not correct', (done) => {
it('fails in error when auth is not correct', async () => {

@@ -475,12 +410,11 @@ const options = {

redis.start((err) => {
await expect((() => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
expect(redis.client).to.not.exist();
done();
});
return redis.start();
})()).to.reject(Error);
expect(redis.client).to.not.exist();
});
it('success when auth is correct', (done) => {
it('success when auth is correct', async () => {

@@ -495,6 +429,7 @@ const options = {

redis.start(done);
await redis.start();
expect(redis.client).to.exist();
});
it('sends select command when database is provided', (done) => {
it('sends select command when database is provided', async () => {

@@ -509,10 +444,7 @@ const options = {

redis.start(() => {
done();
});
await redis.start();
expect(redis.client).to.exist();
});
it('connects to a unix domain socket when one is provided.', (done) => {
it('connects to a unix domain socket when one is provided.', async () => {

@@ -525,12 +457,7 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
const client = redis.client;
expect(client).to.exist();
done();
});
await redis.start();
expect(redis.client).to.exist();
});
it('connects via a Redis URL when one is provided.', (done) => {
it('connects via a Redis URL when one is provided.', async () => {

@@ -543,9 +470,4 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
const client = redis.client;
expect(client).to.exist();
done();
});
await redis.start();
expect(redis.client).to.exist();
});

@@ -556,25 +478,28 @@

const oldCreateClient = RedisClient.createClient;
before((done) => {
before(() => {
RedisClient.createClient = function (opts) {
return new Promise((resolve, reject) => {
const out = new EventEmitter();
process.nextTick(() => {
RedisClient.createClient = function (opts) {
out.emit('ready');
out.removeAllListeners();
});
out.callArgs = opts;
return out;
};
done();
const out = new EventEmitter();
process.nextTick(() => {
out.emit('ready');
out.removeAllListeners();
});
out.callArgs = opts;
return out;
};
resolve();
});
});
after((done) => {
after(() => {
RedisClient.createClient = oldCreateClient;
done();
});
it('connects to a sentinel cluster.', (done) => {
it('connects to a sentinel cluster.', async () => {

@@ -597,15 +522,11 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
const client = redis.client;
expect(client).to.exist();
expect(client.callArgs.sentinels).to.equal(options.sentinels);
expect(client.callArgs.name).to.equal(options.sentinelName);
done();
});
await redis.start();
const client = redis.client;
expect(client).to.exist();
expect(client.callArgs.sentinels).to.equal(options.sentinels);
expect(client.callArgs.name).to.equal(options.sentinelName);
});
});
it('does not stops the client on error post connection', (done) => {
it('does not stops the client on error post connection', async () => {

@@ -619,11 +540,7 @@ const options = {

redis.start((err) => {
await redis.start();
expect(redis.client).to.exist();
expect(err).to.not.exist();
expect(redis.client).to.exist();
redis.client.emit('error', new Error('injected'));
expect(redis.client).to.exist();
done();
});
redis.client.emit('error', new Error('injected'));
expect(redis.client).to.exist();
});

@@ -634,3 +551,3 @@ });

it('returns true when when connected', (done) => {
it('returns true when when connected', async () => {

@@ -644,14 +561,9 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
expect(redis.isReady()).to.equal(true);
redis.stop();
done();
});
await redis.start();
expect(redis.client).to.exist();
expect(redis.isReady()).to.equal(true);
redis.stop();
});
it('returns false when stopped', (done) => {
it('returns false when stopped', async () => {

@@ -665,13 +577,7 @@ const options = {

redis.start((err) => {
expect(err).to.not.exist();
expect(redis.isReady()).to.equal(true);
redis.stop();
expect(redis.isReady()).to.equal(false);
done();
});
await redis.start();
expect(redis.client).to.exist();
expect(redis.isReady()).to.equal(true);
redis.stop();
expect(redis.isReady()).to.equal(false);
});

@@ -682,3 +588,3 @@ });

it('returns an error when the name is empty', (done) => {
it('returns an error when the name is empty', () => {

@@ -696,6 +602,5 @@ const options = {

expect(result.message).to.equal('Empty string');
done();
});
it('returns an error when the name has a null character', (done) => {
it('returns an error when the name has a null character', () => {

@@ -712,6 +617,5 @@ const options = {

expect(result).to.be.instanceOf(Error);
done();
});
it('returns null when there aren\'t any errors', (done) => {
it('returns null when there aren\'t any errors', () => {

@@ -729,3 +633,2 @@ const options = {

expect(result).to.equal(null);
done();
});

@@ -736,3 +639,3 @@ });

it('passes an error to the callback when the connection is closed', (done) => {
it('returns a promise that rejects when the connection is closed', async () => {

@@ -746,12 +649,9 @@ const options = {

redis.get('test', (err) => {
await expect((async () => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
expect(err.message).to.equal('Connection not started');
done();
});
await redis.get('test');
})()).to.reject(Error, 'Connection not started');
});
it('passes an error to the callback when there is an error returned from getting an item', (done) => {
it('returns a promise that rejects when there is an error returned from getting an item', async () => {

@@ -765,17 +665,15 @@ const options = {

redis.client = {
get: function (item, callback) {
get: function (item) {
callback(new Error());
return Promise.reject(Error());
}
};
redis.get('test', (err) => {
await expect((() => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
done();
});
return redis.get('test');
})()).to.reject(Error);
});
it('passes an error to the callback when there is an error parsing the result', (done) => {
it('returns a promise that rejects when there is an error parsing the result', async () => {

@@ -789,17 +687,16 @@ const options = {

redis.client = {
get: function (item, callback) {
callback(null, 'test');
get: function (item) {
return Promise.resolve('test');
}
};
redis.get('test', (err) => {
await expect((() => {
expect(err).to.exist();
expect(err.message).to.equal('Bad envelope content');
done();
});
return redis.get('test');
})()).to.reject(Error, 'Bad envelope content');
});
it('passes an error to the callback when there is an error with the envelope structure (stored)', (done) => {
it('returns a promise that rejects when there is an error with the envelope structure (stored)', async () => {

@@ -813,17 +710,15 @@ const options = {

redis.client = {
get: function (item, callback) {
get: function (item) {
callback(null, '{ "item": "false" }');
return Promise.resolve('{ "item": "false" }');
}
};
redis.get('test', (err) => {
await expect((() => {
expect(err).to.exist();
expect(err.message).to.equal('Incorrect envelope structure');
done();
});
return redis.get('test');
})()).to.reject(Error, 'Incorrect envelope structure');
});
it('passes an error to the callback when there is an error with the envelope structure (item)', (done) => {
it('returns a promise that rejects when there is an error with the envelope structure (item)', async () => {

@@ -837,17 +732,15 @@ const options = {

redis.client = {
get: function (item, callback) {
get: function (item) {
callback(null, '{ "stored": "123" }');
return Promise.resolve('{ "stored": "123" }');
}
};
redis.get('test', (err) => {
await expect((() => {
expect(err).to.exist();
expect(err.message).to.equal('Incorrect envelope structure');
done();
});
return redis.get('test');
})()).to.reject(Error, 'Incorrect envelope structure');
});
it('is able to retrieve an object thats stored when connection is started', (done) => {
it('is able to retrieve an object thats stored when connection is started', async () => {

@@ -865,19 +758,9 @@ const options = {

const redis = new Redis(options);
redis.start(() => {
redis.set(key, 'myvalue', 200, (err) => {
expect(err).to.not.exist();
redis.get(key, (err, result) => {
expect(err).to.not.exist();
expect(result.item).to.equal('myvalue');
done();
});
});
});
await redis.start();
await redis.set(key, 'myvalue', 200);
const result = await redis.get(key);
expect(result.item).to.equal('myvalue');
});
it('returns null when unable to find the item', (done) => {
it('returns null when unable to find the item', async () => {

@@ -895,12 +778,24 @@ const options = {

const redis = new Redis(options);
await redis.start();
const result = await redis.get(key);
expect(result).to.not.exist();
});
redis.start(() => {
it('can store and retrieve falsy values such as int 0', async () => {
redis.get(key, (err, result) => {
const options = {
host: '127.0.0.1',
port: 6379,
partition: 'wwwtest'
};
const key = {
id: 'test',
segment: 'test'
};
expect(err).to.not.exist();
expect(result).to.not.exist();
done();
});
});
const redis = new Redis(options);
await redis.start();
await redis.set(key, 0, 200);
const result = await redis.get(key);
expect(result.item).to.equal(0);
});

@@ -911,3 +806,3 @@ });

it('passes an error to the callback when the connection is closed', (done) => {
it('returns a promise that rejects when the connection is closed', async () => {

@@ -921,12 +816,9 @@ const options = {

redis.set('test1', 'test1', 3600, (err) => {
await expect((async () => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
expect(err.message).to.equal('Connection not started');
done();
});
await redis.set('test1', 'test1', 3600);
})()).to.reject(Error, 'Connection not started');
});
it('passes an error to the callback when there is an error returned from setting an item', (done) => {
it('returns a promise that rejects when there is an error returned from setting an item', async () => {

@@ -942,12 +834,10 @@ const options = {

callback(new Error());
return Promise.reject(Error());
}
};
redis.set('test', 'test', 3600, (err) => {
await expect((() => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
done();
});
return redis.set('test', 'test', 3600);
})()).to.reject(Error);
});

@@ -958,3 +848,3 @@ });

it('passes an error to the callback when the connection is closed', (done) => {
it('returns a promise that rejects when the connection is closed', async () => {

@@ -968,12 +858,9 @@ const options = {

redis.drop('test2', (err) => {
await expect((async () => {
expect(err).to.exist();
expect(err).to.be.instanceOf(Error);
expect(err.message).to.equal('Connection not started');
done();
});
await redis.drop('test2');
})()).to.reject(Error, 'Connection not started');
});
it('deletes the item from redis', (done) => {
it('deletes the item from redis', async () => {

@@ -987,13 +874,9 @@ const options = {

redis.client = {
del: function (key, callback) {
del: function (key) {
callback(null, null);
return Promise.resolve(null);
}
};
redis.drop('test', (err) => {
expect(err).to.not.exist();
done();
});
await redis.drop('test');
});

@@ -1004,3 +887,3 @@ });

it('generates the storage key from a given catbox key', (done) => {
it('generates the storage key from a given catbox key', () => {

@@ -1019,6 +902,5 @@ const options = {

expect(redis.generateKey(key)).to.equal('foo:baz:bar');
done();
});
it('generates the storage key from a given catbox key without partition', (done) => {
it('generates the storage key from a given catbox key without partition', () => {

@@ -1035,3 +917,2 @@ const options = {};

expect(redis.generateKey(key)).to.equal('baz:bar');
done();
});

@@ -1042,3 +923,3 @@ });

it('sets the client to null', (done) => {
it('sets the client to null', async () => {

@@ -1052,11 +933,8 @@ const options = {

redis.start(() => {
expect(redis.client).to.exist();
redis.stop();
expect(redis.client).to.not.exist();
done();
});
await redis.start();
expect(redis.client).to.exist();
redis.stop();
expect(redis.client).to.not.exist();
});
});
});
.npmignore
.travis.yml

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc