keuss 1.7.3 → 2.0.0

package/test/signal.js

@@ -1,196 +0,0 @@
-const should = require ('should');
-const async =  require ('async');
-const _ =      require ('lodash');
-
-const Local = require ('../signal/local');
-const Redis = require ('../signal/redis-pubsub');
-const Mongo = require ('../signal/mongo-capped');
-
-// const whyIsNodeRunning = require('why-is-node-running');
-
-const MongoClient = require ('mongodb').MongoClient;
-
-// setTimeout (() => whyIsNodeRunning(), 9000)
-
-_.forEach ({
-  Local, 
-  Redis, 
-  Mongo
-}, (CL, CLName) => {
-  describe (`${CLName} signaller`, () => {
-
-    before (done => {
-      done();
-    });
-
-    after (done => async.series ([
-      cb => setTimeout (cb, 1000),
-      cb => MongoClient.connect ('mongodb://localhost/keuss_signal', (err, cl) => {
-        if (err) return done (err);
-        cl.db().dropDatabase (() => cl.close (cb))
-      })
-    ], done));
-
-
-    it ('creates ok', done => {
-      CL ({}, (err, factory) => {
-        if (err) return done(err);
-        const q = {ns() {return 'the-ns'}, name () {return 'the-queue'}};
-        const signal = factory.signal (q, {});
-        setTimeout (() => factory.close(done), 500);
-      });
-    });
-    
-
-    it ('signals insertion ok', done => {
-      CL ({}, (err, factory) => {
-        if (err) return done(err);
-        const q = {
-          ns() {return 'the-ns'}, 
-          name () {return 'the-queue'},
-          signalInsertion (d) {
-            d.getTime().should.equal (1234567890);
-            factory.close(done);
-          }
-        };
-
-        const signal = factory.signal (q, {});
-        setTimeout (() => signal.emitInsertion (new Date(1234567890)), 500);
-      });
-    });
-
-    it ('signals pause ok', done => {
-      CL ({}, (err, factory) => {
-        if (err) return done(err);
-        const q = {
-          ns() {return 'the-ns'}, 
-          name () {return 'the-queue'},
-          signalPaused(d) {
-            d.should.equal (true);
-            factory.close(done);
-          }
-        };
-
-        const signal = factory.signal (q, {});
-        setTimeout (() => signal.emitPaused (true), 500);
-      });
-    });
-
-
-    describe (`extra/generic pubsub`, () => {
-      it ('subscribes and receives info ok on 3 subscribers', done => {
-        CL ({}, (err, factory) => {
-          if (err) return done(err);
-          const q = {ns() {return 'the-ns'}, name () {return 'the-queue'}};
-          const signal1 = factory.signal (q, {});
-          const signal2 = factory.signal (q, {});
-          const signal3 = factory.signal (q, {});
-
-          const evs = [];
-
-          function manage (ev) {
-            evs.push (ev);
-            if (evs.length == 3) {
-              evs.should.eql ([
-                { a: 1, b: 'ertwetr' },
-                { a: 1, b: 'ertwetr' },
-                { a: 1, b: 'ertwetr' }
-              ]);
-
-              factory.close(done);
-            }
-          }
-
-          signal1.subscribe_extra ('the-topic', manage);
-          signal2.subscribe_extra ('the-topic', manage);
-          signal3.subscribe_extra ('the-topic', manage);
-
-          setTimeout (() => signal2.emit_extra ('the-topic', {a:1, b:'ertwetr'}), 100);
-        });
-      });
-
-
-      it ('functions across several queues on the same signaller', done => {
-        CL ({}, (err, factory) => {
-          if (err) return done(err);
-          const signal1 = factory.signal ({ns() {return 'the-ns'}, name () {return 'the-queue-1'}}, {});
-          const signal2 = factory.signal ({ns() {return 'the-ns'}, name () {return 'the-queue-2'}}, {});
-          const signal3 = factory.signal ({ns() {return 'the-ns'}, name () {return 'the-queue-3'}}, {});
-
-          const evs = [];
-
-          function manage (ev) {
-            evs.push (ev);
-            if (evs.length == 3) {
-              evs.should.eql ([
-                { a: 1, b: 'ertwetr' },
-                { a: 1, b: 'ertwetr' },
-                { a: 1, b: 'ertwetr' }
-              ]);
-
-              factory.close(done);
-            }
-          }
-
-          signal1.subscribe_extra ('the-topic', manage);
-          signal2.subscribe_extra ('the-topic', manage);
-          signal3.subscribe_extra ('the-topic', manage);
-
-          setTimeout (() => signal2.emit_extra ('the-topic', {a:1, b:'ertwetr'}), 100);
-        });
-      });
-
-      it ('isolates namespaces', done => {
-        CL ({}, (err, factory) => {
-          if (err) return done(err);
-          const signal1 = factory.signal ({ns() {return 'the-ns-1'}, name () {return 'the-queue'}}, {});
-          const signal2 = factory.signal ({ns() {return 'the-ns-2'}, name () {return 'the-queue'}}, {});
-
-          const evs = [];
-
-          async.series ([
-            cb => {signal1.subscribe_extra ('the-topic', ev => evs.push ({src: 1, ev})); cb ();},
-            cb => {signal2.subscribe_extra ('the-topic', ev => evs.push ({src: 2, ev})); cb ();},
-            cb => setTimeout (() => {signal1.emit_extra ('the-topic', {a:1, b:'qwertyuiop'}); cb ()}, 100),
-            cb => setTimeout (() => {signal2.emit_extra ('the-topic', {a:2, b:'asdfghjkl'}); cb ()}, 100),
-            cb => setTimeout (cb, 100),
-          ], err => {
-            if (err) return done(err);
-            evs.should.eql ([
-              { src: 1, ev: { a: 1, b: 'qwertyuiop' } },
-              { src: 2, ev: { a: 2, b: 'asdfghjkl' } }
-            ]);
-            factory.close(done);
-          });
-        });
-      });
-
-      it ('unsubscribes ok and ceases to receive info', done => {
-        CL ({}, (err, factory) => {
-          if (err) return done(err);
-          const signal1 = factory.signal ({ns() {return 'the-ns'}, name () {return 'the-queue'}}, {});
-
-          const evs = [];
-
-          function manage (ev) { evs.push (ev); }
-
-          let subscr = null;
-          async.series ([
-            cb => {subscr = signal1.subscribe_extra ('the-topic', manage); cb ();},
-            cb => setTimeout (() => {signal1.emit_extra ('the-topic', {a:1, b:'ertwetr'}); cb ()}, 100),
-            cb => setTimeout (cb, 100),
-            cb => {signal1.unsubscribe_extra (subscr); cb (); },
-            cb => setTimeout (() => {signal1.emit_extra ('the-topic', {a:2, b:'asdfghjk'}); cb ()}, 100),
-          ], err => {
-            if (err) return done(err);
-            evs.should.eql ([ { a: 1, b: 'ertwetr' } ]);
-            factory.close(done);
-          });
-        });
-      });
-    
-    });
-
-
-  });
-});

package/test/stats.js

@@ -1,296 +0,0 @@
-
-//var log = require('why-is-node-running')
-
-var should = require ('should');
-var async =  require ('async');
-var _ =      require ('lodash');
-
-var Mem =   require ('../stats/mem');
-var Redis = require ('../stats/redis');
-var Mongo = require ('../stats/mongo');
-
-const MongoClient = require ('mongodb').MongoClient;
-
-var ns = 'some-class';
-var name = 'test-stats';
-
-
-_.forEach ({
-  Mem: Mem,
-  Redis: Redis,
-  Mongo: Mongo
-}, (CL, CLName) => {
-
-  describe (CLName + ' stats provider', function () {
-
-    before (done => {
-      done();
-    });
-
-    after (done => async.series ([
-      cb => setTimeout (cb, 1000),
-      cb => MongoClient.connect ('mongodb://localhost/keuss_stats', (err, cl) => {
-        if (err) return done (err);
-        cl.db().dropDatabase (() => cl.close (cb))
-      })
-    ], done));
-
-    it ('creates ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-        ], () => {
-          mem.values (function (err, vals) {
-            vals.should.eql ({});
-            ftry.close(done);
-          });
-        });
-      });
-    });
-
-    it ('initializes ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 1, cb),
-          cb => mem.incr ('v2', 1, cb),
-          cb => mem.incr ('v3', 1, cb)
-        ], (err, results) => {
-          async.series ([
-            cb => setTimeout (cb, 200),
-            cb => mem.values (cb),
-            cb => mem.paused (cb)
-          ], (err, res) => {
-            if (err) return done (err);
-            mem.ns().should.equal (ns);
-            mem.name().should.equal (name);
-            res[1].should.eql ({v1: 1, v2: 1, v3: 1});
-            res[2].should.eql (false);
-            mem.clear (() => ftry.close(done));
-          });
-        });
-      });
-    });
-
-    it ('increments (default by 1) ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 0, cb),
-          cb => mem.incr ('v1', undefined, cb),
-          cb => mem.incr ('v1', undefined, cb)
-        ], (err, results) => {
-          setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({v1: 2});
-            mem.clear (() => ftry.close(done));
-          }), 200);
-        });
-      });
-    });
-
-    it ('increments (explicit deltas) ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 0, cb),
-          cb => mem.incr ('v1', undefined, cb),
-          cb => mem.incr ('v1', 3, cb)
-        ], (err, results) => {
-          setTimeout ( () => mem.values ((err, vals) => {
-            vals.should.eql ({v1: 4});
-            ftry.close(done);
-          }), 200);
-        });
-      });
-    });
-
-    it ('decrements (default by 1) ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 1, cb),
-          cb => mem.incr ('v1', undefined, cb),
-          cb => mem.decr ('v1', undefined, cb)
-        ], (err, results) => {
-          setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({v1: 1});
-            ftry.close(done);
-          }), 200);
-        });
-      });
-    });
-
-    it ('decrements (explicit deltas) ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 0, cb),
-          cb => mem.incr ('v1', 6, cb),
-          cb => mem.decr ('v1', 4, cb),
-          cb => setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({v1: 2});
-            cb();
-          }), 200),
-          cb => mem.decr ('v1', 4, cb),
-          cb => setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({v1: -2});
-            cb();
-          }), 200)
-        ], (err, results) => {
-          ftry.close();
-          done (err);
-        });
-      });
-    });
-
-
-    it ('manages pause/resume ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.paused (cb),
-          cb => mem.paused (true, cb),
-          cb => mem.paused (cb),
-          cb => mem.paused (false, cb),
-          cb => mem.paused (cb),
-          cb => mem.paused (false, cb),
-          cb => mem.paused (cb),
-          cb => setTimeout (cb, 200)
-        ], (err, results) => {
-          results.should.eql ([ undefined,
-  false,
-  undefined,
-  true,
-  undefined,
-  false,
-  undefined,
-  false,
-  undefined ]);
-          ftry.close();
-          done (err);
-        });
-      });
-    });
-
-    it ('manages concise & full listing ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem1 = ftry.stats (ns, name);
-        var mem2 = ftry.stats (ns, name + '-2');
-        var opts1 = {s:0, a: 'yy'};
-        var opts2 = {s:7, at: 'yy--j'};
-
-        async.series([
-          cb => mem1.clear (cb),
-          cb => mem2.clear (cb),
-          cb => mem1.opts (opts1, cb),
-          cb => mem2.opts (opts2, cb),
-          cb => mem1.incr ('v1', 8, cb),
-          cb => mem1.incr ('v2', 6, cb),
-          cb => mem2.incr ('v1', 4, cb),
-          cb => mem2.incr ('v3', 45, cb),
-          cb => setTimeout (() => ftry.queues (ns, (err, res) => {
-            if (err) return cb (err);
-            res.sort().should.eql ([ 'test-stats', 'test-stats-2' ]);
-            cb ();
-          }), 200),
-          cb => setTimeout (() => ftry.queues (ns, {full: true}, (err, res) => {
-            if (err) return cb (err);
-            res.should.eql ({
-              'test-stats': { name: 'test-stats', ns: 'some-class', opts: opts1, counters: {v1: 8, v2: 6 }, paused: false },
-              'test-stats-2': { name: 'test-stats-2', ns: 'some-class', opts: opts2, counters: {v1: 4, v3: 45}, paused: false }
-            });
-
-            cb ();
-          }), 200)
-        ], (err, results) => {
-          ftry.close();
-          done (err);
-        });
-      });
-    });
-
-    it ('clears ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('v1', 0, cb),
-          cb => mem.incr ('v1', 6, cb),
-          cb => mem.incr ('v2', 6, cb),
-          cb => mem.decr ('v2', 4, cb),
-          cb => setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({v1: 6, v2: 2});
-            cb();
-          }), 200),
-          cb => mem.clear (cb),
-          cb => setTimeout (() => mem.values ((err, vals) => {
-            vals.should.eql ({});
-            cb();
-          }), 200)
-        ], (err, results) => {
-          ftry.close();
-          done (err);
-        });
-      });
-    });
-
-
-    it ('managed hierarchy (dotted keys) ok', done => {
-      CL ((err, ftry) => {
-        if (err) return done(err);
-        var mem = ftry.stats (ns, name);
-
-        async.series([
-          cb => mem.clear (cb),
-          cb => mem.incr ('l1.l2.c', -1, cb),
-          cb => mem.incr ('l1.l2.b', 1, cb),
-          cb => mem.incr ('l1.l3.a', 7, cb),
-          cb => mem.incr ('v1', 3, cb),
-        ], (err, results) => {
-          setTimeout ( () => mem.values ((err, vals) => {
-            vals.should.eql ({
-              l1: {
-                l2: {
-                  b: 1,
-                  c: -1
-                },
-                l3: {
-                  a: 7
-                }
-              },
-              v1: 3
-            });
-            
-            ftry.close(done);
-          }), 200);
-        });
-      });
-    });
-
-
-  });
-});

package/test/stream-mongo.js

@@ -1,166 +0,0 @@
-var async =  require ('async');
-var should = require ('should');
-var _ =      require ('lodash');
-
-var LocalSignal = require ('../signal/local');
-var MemStats =    require ('../stats/mem');
-
-const MongoClient = require ('mongodb').MongoClient;
-
-
-function stats (q, cb) {
-  async.series ({
-    stats: cb => q.stats(cb),
-    tsize: cb => q.totalSize(cb)
-  }, (err, res) => {
-//    console.log ('stats:', res);
-    cb (err, res);
-  });
-}
-
-function get_mq_factory (MQ, opts, cb) {
-  const common_opts = {
-    url: 'mongodb://localhost/keuss_test_backends_stream_mongo',
-    signaller: { provider: LocalSignal},
-    stats: {provider: MemStats},
-  };
-
-  // initialize factory
-  MQ (_.merge ({}, common_opts, opts), cb);
-}
-
-function release_mq_factory (factory, cb) {
-//  console.log ('releasing mq factory');
-
-  setTimeout (() => {
-    factory.close (cb);
-  }, 1000);
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-[
-  {label: 'Stream MongoDB',  mq: require ('../backends/stream-mongo')},
-].forEach (MQ_item => {
-  describe('stream operations with ' + MQ_item.label + ' queue backend', () => {
-    const MQ = MQ_item.mq;
-
-    beforeEach (done => {
-      done();
-    });
-
-    afterEach (done => async.series ([
-      cb => setTimeout (cb, 1000),
-      cb => MongoClient.connect ('mongodb://localhost/keuss_test_backends_stream_mongo', (err, cl) => {
-        if (err) return done (err);
-        cl.db().dropDatabase (() => cl.close (cb))
-      })
-    ], done));
-
-
-    it('pushes one message, reads it on 3 clients', done => {
-      const pl = {elem: 1, pl: 'twetrwte'};
-      const hdrs = {aaa: 'qw', bbb: '666'};
-
-      async.waterfall ([
-        cb => get_mq_factory (MQ, {}, cb),
-        (factory, cb) => {
-          const q0 = factory.queue('test_queue_1', {groups: '000, 001, 002, 003'});
-          const q1 = factory.queue('test_queue_1', {group: '000'});
-          const q2 = factory.queue('test_queue_1', {group: '001'});
-          const q3 = factory.queue('test_queue_1', {group: '002'});
-
-          async.parallel ([
-            cb => setTimeout (() => q0.push (pl, {hdrs}, cb), 1111),
-            cb => q1.pop ('c1', cb),
-            cb => q2.pop ('c2', cb),
-            cb => q3.pop ('c3', cb),
-          ], (err, res) => {
-            if (err) return done (err);
-            res[1].should.eql (res[2]);
-            res[2].should.eql (res[3]);
-            res[1].payload.should.eql (pl);
-            res[1].hdrs.should.eql (hdrs);
-            cb (err, factory);
-          });
-        },
-        (factory, cb) => release_mq_factory (factory, cb)
-      ], done);
-    });
-
-
-    it('pushes one message, unaware cients do not get it', done => {
-      const pl = {elem: 1, pl: 'twetrwte'};
-      const hdrs = {aaa: 'qw', bbb: '666'};
-
-      async.waterfall ([
-        cb => get_mq_factory (MQ, {}, cb),
-        (factory, cb) => {
-          const q0 = factory.queue('test_queue_1', {groups: '000, 001, 002, 003'});
-          const q1 = factory.queue('test_queue_1', {group: '000'});
-          const q2 = factory.queue('test_queue_1', {group: '001'});
-          const q3 = factory.queue('test_queue_1', {group: '004'});
-          const q4 = factory.queue('test_queue_1', {group: '005'});
-
-          async.parallel ([
-            cb => setTimeout (() => q0.push (pl, {hdrs}, cb), 1111),
-            cb => q1.pop ('c1', cb),
-            cb => q2.pop ('c2', cb),
-            cb => q3.pop ('c3', {timeout: 2000}, err => cb (null, err)),
-            cb => q4.pop ('c4', {timeout: 2000}, err => cb (null, err)),
-          ], (err, res) => {
-            if (err) return done (err);
-            res[1].should.eql (res[2]);
-            res[1].payload.should.eql (pl);
-            res[1].hdrs.should.eql (hdrs);
-            res[3].timeout.should.be.true;
-            res[4].timeout.should.be.true;
-            cb (err, factory);
-          });
-        },
-        (factory, cb) => release_mq_factory (factory, cb)
-      ], done);
-    });
-
-    it('pushes one message, only on of several clients on same group get it', done => {
-      const pl = {elem: 1, pl: 'twetrwte'};
-      const hdrs = {aaa: 'qw', bbb: '666'};
-
-      async.waterfall ([
-        cb => get_mq_factory (MQ, {}, cb),
-        (factory, cb) => {
-          const q0 = factory.queue('test_queue_1', {groups: '000, 001, 002, 003'});
-          const q1 = factory.queue('test_queue_1', {group: '000'});
-          const q2 = factory.queue('test_queue_1', {group: '000'});
-          const q3 = factory.queue('test_queue_1', {group: '001'});
-          const q4 = factory.queue('test_queue_1', {group: '001'});
-
-          async.parallel ([
-            cb => setTimeout (() => q0.push (pl, {hdrs}, cb), 1111),
-            cb => q1.pop ('c1', {timeout: 2000}, (err, res) => cb (null, res || err)),
-            cb => q2.pop ('c2', {timeout: 2000}, (err, res) => cb (null, res || err)),
-            cb => q3.pop ('c3', {timeout: 2000}, (err, res) => cb (null, res || err)),
-            cb => q4.pop ('c4', {timeout: 2000}, (err, res) => cb (null, res || err)),
-          ], (err, res) => {
-            if (err) return done (err);
-
-            function __calc__ (ra) {
-              const res = {ok:0, ko:0};
-              ra.forEach (r => {
-                if (r.timeout === true) res.ko++;
-                else if (r.payload.elem == 1) res.ok++;
-              });
-              return res;
-            }
-
-            __calc__ ([res[1], res[2]]).should.eql ({ok:1, ko:1});
-            __calc__ ([res[3], res[4]]).should.eql ({ok:1, ko:1});
-            cb (err, factory);
-          });
-        },
-        (factory, cb) => release_mq_factory (factory, cb)
-      ], done);
-    });
-
-  });
-});