fmem-mapcache-redis/test/redismapcache.spec.js

Redis MapCache for fmem

var chai = require('chai');
var expect = chai.expect;
var MapCache = require('../lib/mapcache-redis');
var redisMapCacheConfig1 = {
  redis:{
    host: "127.0.0.1",
    port: "6379",
    db: 1
  }
};
var redisMapCacheConfig2 = {
  redis:{
    host: "127.0.0.1",
    port: "6379",
    db: 2
  }
};

describe('MapCache', function() {

  beforeEach(function(done) {
    var mc1 = new MapCache(redisMapCacheConfig1);
    var mc2 = new MapCache(redisMapCacheConfig2);

    mc1.clear(function(err){
      mc2.clear(function(err){
        done();
      })
    })
  });

  describe('Basic Cache Test', function() {
    it('create a map cache and store test data, retrieved data should be identical', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';

      mc.set(keyA, valA, function(e){
        expect(e).to.equal(null);
      });
      mc.set(keyB, valB, function(e){
        expect(e).to.equal(null);
      });
      mc.set(keyC, valC, function(e){
        expect(e).to.equal(null);
      });

      mc.get(keyA, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valA);
      });
      mc.get(keyB, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valB);
      });
      mc.get(keyC, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valC);
      });

      done();
    })
  })

  describe('Basic Cache Test Async', function() {
    it('create a map cache and store test data, retrieved data should be identical', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';

      mc.clear()
      .then( () => mc.set(keyA, valA) )
      .then( () => mc.set(keyB, valB) )
      .then( () => mc.set(keyC, valC) )
      .then( () => mc.get(keyA) )
      .catch( (e) => expect(e).to.not.exist )
      .then( (kv) => expect(kv.v).to.equal(valA) )
      .then( () => mc.get(keyB) )
      .catch( (e) => expect(e).to.not.exist )
      .then( (kv) => expect(kv.v).to.equal(valB) )
      .then( () => mc.get(keyC) )
      .catch( (e) => {console.log(JSON.stringify(e)); expect(e).to.not.exist} )
      .then( (kv) => expect(kv.v).to.equal(valC) )
      .then( () => done() )
      .catch( (e) => done(e) )
      ;
    })
  })

  describe('Multiple Cache Instances', function() {
    it('test for multiple instances', function(done) {
      var mc1 = new MapCache(redisMapCacheConfig1);
      var mc2 = new MapCache(redisMapCacheConfig2);

      var keyA = 'keyA', valA1 = 'valueA', valA2 = 'A2';
      var keyB = 'keyB', valB1 = '2', valB2 = '53';
      var keyC = 'keyC', valC1 = '{"insideKey1":1,"insideKey2":2}', valC2 = '027kxk12z';

      mc1.set(keyA, valA1, function(e){
        expect(e).to.equal(null);
      });
      mc1.set(keyB, valB1, function(e){
        expect(e).to.equal(null);
      });
      mc1.set(keyC, valC1, function(e){
        expect(e).to.equal(null);
      });

      mc1.get(keyA, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valA1);
      });
      mc1.get(keyB, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valB1);
      });
      mc1.get(keyC, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valC1);
      });

      mc2.set(keyA, valA2, function(e){
        expect(e).to.equal(null);
      });
      mc2.set(keyB, valB2, function(e){
        expect(e).to.equal(null);
      });
      mc2.set(keyC, valC2, function(e){
        expect(e).to.equal(null);
      });

      mc2.get(keyA, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valA2);
      });
      mc2.get(keyB, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valB2);
      });
      mc2.get(keyC, function(e,kv){
        expect(e).to.equal(null);
        expect(kv.v).to.equal(valC2);
      });

      done();
    })
  })

  describe('Multiple Cache Instances Async', function() {
    it('test for multiple instances', function(done) {
      var mc1 = new MapCache(redisMapCacheConfig1);
      var mc2 = new MapCache(redisMapCacheConfig2);

      var keyA = 'keyA', valA1 = 'valueA', valA2 = 'A2';
      var keyB = 'keyB', valB1 = '2', valB2 = '53';
      var keyC = 'keyC', valC1 = '{"insideKey1":1,"insideKey2":2}', valC2 = '027kxk12z';

      Promise.all([
        mc1.set(keyA, valA1)
        .then( () => mc1.set(keyB, valB1) )
        .then( () => mc1.set(keyC, valC1) )
        .then( () => mc1.get(keyA) )
        .catch( (e) => expect(e).to.not.exist )
        .then( (kv) => expect(kv.v).to.equal(valA1) )
        .then( () => mc1.get(keyB) )
        .catch( (e) => expect(e).to.not.exist )
        .then( (kv) => expect(kv.v).to.equal(valB1) )
        .then( () => mc1.get(keyC) )
        .catch( (e) => {console.log(JSON.stringify(e)); expect(e).to.not.exist} )
        .then( (kv) => expect(kv.v).to.equal(valC1) )
      ,
        mc2.set(keyA, valA2)
        .then( () => mc2.set(keyB, valB2) )
        .then( () => mc2.set(keyC, valC2) )
        .then( () => mc2.get(keyA) )
        .catch( (e) => expect(e).to.not.exist )
        .then( (kv) => expect(kv.v).to.equal(valA2) )
        .then( () => mc2.get(keyB) )
        .catch( (e) => expect(e).to.not.exist )
        .then( (kv) => expect(kv.v).to.equal(valB2) )
        .then( () => mc2.get(keyC) )
        .catch( (e) => {console.log(JSON.stringify(e)); expect(e).to.not.exist} )
        .then( (kv) => expect(kv.v).to.equal(valC2) )
      ]).then( () => done() )
      .catch( (e) => done(e) )

    })
  })

  describe('Cache Miss', function() {
    it('test for cache miss', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      mc.get('keyA', function(e,v){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(v).to.not.exist;
      });

      mc.get('keyB', function(e,v){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(v).to.not.exist;
      });

      done();
    })
  })

  describe('Cache Miss Async', function() {
    it('test for cache miss', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      mc.get('keyA')
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => mc.get('keyB') )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => done() )
    })
  })

  describe('Cache Delete', function() {
    it('test for cache delete', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';

      mc.set(keyA, valA);
      mc.set(keyB, valB, function(e){
        expect(e).to.not.exist;
      });
      mc.set(keyC, valC);

      mc.del(keyA);
      mc.del(keyB, function(e){
        expect(e).to.not.exist;
      })

      mc.get(keyA, function(e,kv){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(kv).to.not.exist;
      });
      mc.get(keyB, function(e,kv){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(kv).to.not.exist;
      });
      mc.get(keyC, function(e,kv){
        expect(e).to.not.exist;
        expect(kv.v).to.equal(valC);
      });

      done();
    })
  })

  describe('Cache Delete Async', function() {
    it('test for cache delete', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';
      
      mc.set(keyA, valA)
      .then( () => mc.set(keyB, valB) )
      .then( () => mc.set(keyC, valC) )
      .then( () => mc.del(keyA) )
      .then( () => mc.del(keyB) )
      .then( () => mc.get(keyA) )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => mc.get(keyB) )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => mc.get(keyC) )
      .then( () => done() )
      .catch( (e) => done(e) )
    })
  })

  describe('Cache Clear', function() {
    it('test for cache clear', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';

      mc.set(keyA, valA);
      mc.set(keyB, valB, function(e){
        expect(e).to.not.exist;
      });
      mc.set(keyC, valC);

      mc.clear();

      mc.get(keyA, function(e,v){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(v).to.not.exist;
      });
      mc.get(keyB, function(e,v){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(v).to.not.exist;
      });
      mc.get(keyC, function(e,v){
        expect(e).to.exist.and.be.instanceof(Error);
        expect(v).to.not.exist;
      });

      done();
    })
  })

  describe('Cache Clear Async', function() {
    it('test for cache clear', function(done) {
      var mc = new MapCache(redisMapCacheConfig1);

      var keyA = 'keyA', valA = 'valueA';
      var keyB = 'keyB', valB = '2';
      var keyC = 'keyC', valC = '{"insideKey1":1,"insideKey2":2}';

      mc.set(keyA, valA)
      .then( () => mc.set(keyB, valB) )
      .then( () => mc.set(keyC, valC) )
      .then( () => mc.clear() )
      .catch( (e) => done(e) )
      .then( () => mc.get(keyA) )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => mc.get(keyB) )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => mc.get(keyC) )
      .then( () => done('cache should be missed') )
      .catch( (e) => expect(e).to.exist.and.be.instanceof(Error) )
      .then( () => done() )
    })
  })
})