ionic-framework/test/unit/angular/service/delegateService.unit.js

describe('DelegateFactory', function() {
  function setup(methods) {
    var delegate;
    inject(function($log, $injector) {
      delegate = $injector.instantiate(ionic.DelegateService(methods || []));
    });
    return delegate;
  }

  it('should have properties', function() {
    expect(setup()._instances).toEqual([]);
    expect(setup()._registerInstance).toEqual(jasmine.any(Function));
    expect(setup().$getByHandle).toEqual(jasmine.any(Function));
  });

  it('should allow reg & dereg of instance with handle', function() {
    var delegate = setup();
    var instance = {};
    var deregister = delegate._registerInstance(instance, 'handle');
    expect(instance.$$delegateHandle).toBe('handle');
    expect(delegate._instances[0]).toBe(instance);
    deregister();
    expect(delegate._instances.length).toBe(0);
  });

  it('should allow reg & dereg of instance, without handle', function() {
    var delegate = setup();
    var instance = {};
    var deregister = delegate._registerInstance(instance, null);
    expect(instance.$$delegateHandle).toBe(null);
    expect(delegate._instances[0]).toBe(instance);
    deregister();
    expect(delegate._instances.length).toBe(0);
  });

  it('should have given methodNames on root', function() {
    var delegate = setup(['foo', 'bar']);
    expect(delegate.foo).toEqual(jasmine.any(Function));
    expect(delegate.bar).toEqual(jasmine.any(Function));
  });

  it('should call given methodNames on all instances with args', function() {
    var delegate = setup(['foo', 'bar']);
    var instance1 = {
      foo: jasmine.createSpy('foo1'),
      bar: jasmine.createSpy('bar1')
    };
    var instance2 = {
      foo: jasmine.createSpy('foo1'),
      bar: jasmine.createSpy('bar1')
    };
    delegate._registerInstance(instance1);
    delegate._registerInstance(instance2);

    expect(instance1.foo).not.toHaveBeenCalled();
    expect(instance2.foo).not.toHaveBeenCalled();
    delegate.foo('a', 'b', 'c');
    expect(instance1.foo).toHaveBeenCalledWith('a', 'b', 'c');
    expect(instance2.foo).toHaveBeenCalledWith('a', 'b', 'c');

    instance1.foo.reset();
    instance2.foo.reset();
    delegate.foo(1, 2, 3);
    expect(instance1.foo).toHaveBeenCalledWith(1, 2, 3);
    expect(instance2.foo).toHaveBeenCalledWith(1, 2, 3);

    expect(instance1.bar).not.toHaveBeenCalled();
    expect(instance2.bar).not.toHaveBeenCalled();
    delegate.bar('something');
    expect(instance1.bar).toHaveBeenCalledWith('something');
    expect(instance2.bar).toHaveBeenCalledWith('something');
  });

  it('should return the first return value from multiple instances', function() {
    var delegate = setup(['fn']);
    var instance1 = {
      fn: jasmine.createSpy('fn').andReturn('ret1')
    };
    var instance2 = {
      fn: jasmine.createSpy('fn').andReturn('ret2')
    };
    var deregister = delegate._registerInstance(instance1);
    delegate._registerInstance(instance2);

    expect(delegate.fn()).toBe('ret1');
    deregister();
    expect(delegate.fn()).toBe('ret2');
  });

  it('should return the first active instance return value when multiple instances w/ undefined handle', function() {
    var delegate = setup(['fn']);
    var instance1 = {
      fn: jasmine.createSpy('fn').andReturn('ret1')
    };
    var instance2 = {
      fn: jasmine.createSpy('fn').andReturn('ret2')
    };
    delegate._registerInstance(instance1, undefined, function() {
      return false;
    });
    delegate._registerInstance(instance2, undefined, function() {
      return true;
    });

    expect(instance1.fn).not.toHaveBeenCalled();
    expect(delegate.fn()).toBe('ret2');
  });

  it('should return the first active instance return value when multiple instances w/ same handle', function() {
    var delegate = setup(['fn']);
    var instance1 = {
      fn: jasmine.createSpy('fn').andReturn('ret1')
    };
    var instance2 = {
      fn: jasmine.createSpy('fn').andReturn('ret2')
    };
    delegate._registerInstance(instance1, 'myhandle', function() {
      return true;
    });
    delegate._registerInstance(instance2, 'myhandle', function() {
      return false;
    });

    expect(instance2.fn).not.toHaveBeenCalled();
    expect(delegate.fn()).toBe('ret1');
  });

  describe('$getByHandle', function() {
    var delegate, instance1, instance2, instance3;
    beforeEach(function() {
      delegate = setup(['a']);
      instance1 = {
        a: jasmine.createSpy('a1').andReturn('a1')
      };
      instance2 = {
        a: jasmine.createSpy('a2').andReturn('a2')
      };
      instance3 = {
        a: jasmine.createSpy('a3').andReturn('a3')
      };
    });

    it('should return an InstanceWithHandle object with fields', function() {
      expect(delegate.$getByHandle('one').a).toEqual(jasmine.any(Function));
      expect(delegate.$getByHandle('two').a).toEqual(jasmine.any(Function));
      expect(delegate.$getByHandle('invalid').a).toEqual(jasmine.any(Function));
    });

    it('should noop & warn if calling for a non-added instance', inject(function($log) {
      spyOn($log, 'warn');
      expect(delegate.$getByHandle('one').a()).toBeUndefined();
      expect($log.warn).toHaveBeenCalled();
    }));

    it('should call an added instance\'s method', function() {
      delegate._registerInstance(instance1, '1');
      delegate._registerInstance(instance2, '2');

      var result = delegate.$getByHandle('1').a(1,2,3);
      expect(instance1.a).toHaveBeenCalledWith(1,2,3);
      expect(instance2.a).not.toHaveBeenCalled();
      expect(result).toBe('a1');

      instance1.a.reset();
      result = delegate.$getByHandle('2').a(2,3,4);
      expect(instance2.a).toHaveBeenCalledWith(2,3,4);
      expect(instance1.a).not.toHaveBeenCalled();
      expect(result).toBe('a2');
    });

    it('should call multiple instances with the same handle', function() {
      var deregister = delegate._registerInstance(instance1, '1');
      delegate._registerInstance(instance2, '1');
      delegate._registerInstance(instance3, 'other');

      var delegateInstance = delegate.$getByHandle('1');

      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).not.toHaveBeenCalled();
      expect(instance3.a).not.toHaveBeenCalled();
      var result = delegateInstance.a('1');
      expect(instance1.a).toHaveBeenCalledWith('1');
      expect(instance2.a).toHaveBeenCalledWith('1');
      expect(instance3.a).not.toHaveBeenCalled();
      expect(result).toBe('a1');

      instance1.a.reset();
      deregister();
      result = delegateInstance.a(2);
      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).toHaveBeenCalledWith(2);
      expect(instance3.a).not.toHaveBeenCalled();
      expect(result).toBe('a2');
    });

    it('should get the only active instance from multiple instances with the same handle', function() {
      delegate._registerInstance(instance1, 'myhandle', function() { return false; });
      delegate._registerInstance(instance2, 'myhandle', function() { return true; });
      delegate._registerInstance(instance3, 'myhandle', function() { return false; });

      var delegateInstance = delegate.$getByHandle('myhandle');

      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).not.toHaveBeenCalled();
      expect(instance3.a).not.toHaveBeenCalled();

      var result = delegateInstance.a('test-a');
      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).toHaveBeenCalledWith('test-a');
      expect(instance3.a).not.toHaveBeenCalled();
      expect(result).toBe('a2');
    });

    it('should get active instance when multiple sname name handles, among multiple active instances', function() {
      delegate._registerInstance(instance1, 'myhandle-1', function() { return true; });
      delegate._registerInstance(instance2, 'myhandle-2', function() { return false; });
      delegate._registerInstance(instance3, 'myhandle-2', function() { return true; });

      var delegateInstance = delegate.$getByHandle('myhandle-2');

      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).not.toHaveBeenCalled();
      expect(instance3.a).not.toHaveBeenCalled();

      var result = delegateInstance.a('test-a');
      expect(instance1.a).not.toHaveBeenCalled();
      expect(instance2.a).not.toHaveBeenCalled();
      expect(instance3.a).toHaveBeenCalledWith('test-a');
      expect(result).toBe('a3');
    });

  });
});