peer-emitter/tests/events.js

acknowledgeable events

var test = require('tap').test;

var DuplexPair = require('./utils/duplex-pair');

var PeerEmitter = require('..');

function xtest() {}

test('fire-and-forget events', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream);
    emitter.emit('evt1', arg1, arg2);
  }

  function receiver(duplexStream) {
    var emitter = PeerEmitter(duplexStream);
    emitter.on('evt1', function(a1, a2) {
      t.equals(a1, arg1, 'arg1 is correct');
      t.equals(a2, arg2, 'arg2 is correct');
      t.end();
    });
  }

  receiver(pair.a);
  sender(pair.b);
});

test('acknowlegded', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream);

    emitter.emit('evt1', arg1, arg2, function(timeout) {
      t.notOk(timeout, 'did not timeout');
      t.end();
    });
  }

  function receiver(duplexStream) {
    var emitter = PeerEmitter(duplexStream);

    emitter.on('evt1', function(a1, a2, ack) {
      
      t.equals(a1, arg1, 'arg1 is correct');
      t.equals(a2, arg2, 'arg2 is correct');
      t.ok(typeof ack === 'function', 'ack is a function');

      ack();
    });
  }

  receiver(pair.a);
  sender(pair.b);
});

test('auto acknowledge', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream);

    emitter.emit('evt1', arg1, arg2, function(timeout) {
      t.notOk(timeout, 'did not timeout');
      t.end();
    });
  }

  function receiver(duplexStream) {
    var emitter = PeerEmitter(duplexStream);

    emitter.on('evt1', function(a1, a2) {
      t.equals(a1, arg1, 'arg1 is correct');
      t.equals(a2, arg2, 'arg2 is correct');
    });
  }

  receiver(pair.a);
  sender(pair.b);
});

test('no handler timeout', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream, { timeout: 20 });

    emitter.emit('evt1', arg1, arg2, function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  }

  sender(pair.b);
});

test('didn\'t call ack timeout', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream, { timeout: 20 });

    emitter.emit('evt1', arg1, arg2, function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  }

  function receiver(duplexStream) {
    var emitter = PeerEmitter(duplexStream);

    emitter.on('evt1', function(a1, a2, ack) {
      t.equals(a1, arg1, 'arg1 is correct');
      t.equals(a2, arg2, 'arg2 is correct');
      t.ok(typeof ack === 'function', 'ack is a function');
    });
  }

  receiver(pair.a);
  sender(pair.b);
});

test('skipped ack', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterA.emit('evt1', arg1, arg2, function(timeout) {
    t.ok(timeout, 'did timeout');
    t.end();
  });

  var arg3 = Math.random().toString();
  var arg4 = Math.random().toString();

  emitterB.on('evt1', function(a3, a4, ack) {
    t.equals(a3, arg3, 'arg3 is correct');
    t.equals(a4, arg4, 'arg4 is correct');
    t.ok(typeof ack === 'function', 'ack is a function');

    ack();
  });

  emitterA.emit('evt1', arg3, arg4, function(timeout) {
    t.notOk(timeout, 'did not timeout');
  });
});

test('timeout doesn\'t fire after ack', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.on('evt1', handler);
  function handler(ack) { ack(); }

  var count = 0;

  emitterA.emit('evt1', function(timeout) {
    t.notOk(timeout, 'did not timeout');
    ++count;
  });

  setTimeout(function() {
    t.equals(count, 1, 'ack cb fired exactly once');
    t.end();
  }, 100);
});

test('ack does\'t fire after timeout', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.on('evt1', handler);
  function handler(ack) { setTimeout(ack, 60); }

  var count = 0;

  emitterA.emit('evt1', function(timeout) {
    t.ok(timeout, 'did timeout');
    ++count;
  });

  setTimeout(function() {
    t.equals(count, 1, 'ack cb fired exactly once');
    t.end();
  }, 200);
});

test('addListener is same as on', function(t) {
  var emitter = PeerEmitter(DuplexPair().a);
  t.equals(emitter.on, emitter.addListener, 'same function');
  t.end();
});

test('removeListener', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.on('evt1', handler);
  function handler(ack) { ack(); }

  emitterA.emit('evt1', function(timeout) {
    t.notOk(timeout, 'did not timeout');

    emitterB.removeListener('evt1', handler);
    emitterA.emit('evt1', function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  });
});


test('ack cb fires only once', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.once('evt1', handler);
  function handler(ack) { ack(); }
  var count = 0;
  emitterA.emit('evt1', function(timeout) {
    ++count;
  });

  setTimeout(function() {
    t.equals(count, 1);
    t.end();
  }, 200);
});

test('once works', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.once('evt1', handler);
  function handler(ack) { ack(); }

  emitterA.emit('evt1', function(timeout) {
    t.notOk(timeout, 'did not timeout');
    emitterA.emit('evt1', function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  });
});

test('removeAllListeners(evtName) works', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.on('evt1', handler);
  function handler(ack) { ack(); }

  emitterA.emit('evt1', function(timeout) {
    t.notOk(timeout, 'did not timeout');

    emitterB.removeAllListeners('evt1');
    emitterA.emit('evt1', function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  });
});

test('removeAllListeners() works', function(t) {
  var pair = DuplexPair();

  var emitterA = PeerEmitter(pair.a, { timeout: 40 });
  var emitterB = PeerEmitter(pair.b);

  emitterB.on('evt1', handler);
  function handler(ack) { ack(); }

  emitterA.emit('evt1', function(timeout) {
    t.notOk(timeout, 'did not timeout');

    emitterB.removeAllListeners();
    emitterA.emit('evt1', function(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    });
  });
});

test('custom timeout', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream, { timeout: 99000 });

    function onAck(timeout) {
      t.ok(timeout, 'did timeout');
      t.end();
    }

    onAck.timeout = 40;

    emitter.emit('evt1', arg1, arg2, onAck);
  }

  sender(pair.b);
});

test('registering a handler is an idempotent operation', function(t) {
  var pair = DuplexPair();

  var arg1 = Math.random().toString();
  var arg2 = Math.random().toString();
  var count = 0;

  function sender(duplexStream) {
    var emitter = PeerEmitter(duplexStream);
    emitter.emit('evt');
  }

  function receiver(duplexStream) {
    var emitter = PeerEmitter(duplexStream);
    emitter.on('evt', handler);
    emitter.on('evt', handler);

    function handler() {
      ++count;
    }
  }

  receiver(pair.a);
  sender(pair.b);

  setTimeout(function() {
    t.equals(count, 1, 'handler fired exactly once');
    t.end();
  }, 50);
});