iqvoc 4.8.1 → 4.8.2

data/vendor/assets/bower_components/typeahead.js/test/transport_spec.js

@@ -0,0 +1,197 @@
+describe('Transport', function() {
+
+  beforeEach(function() {
+    jasmine.Ajax.useMock();
+    jasmine.Clock.useMock();
+
+    this.transport = new Transport();
+  });
+
+  afterEach(function() {
+    // run twice to flush out  on-deck requests
+    $.each(ajaxRequests, drop);
+    $.each(ajaxRequests, drop);
+
+    clearAjaxRequests();
+    Transport.resetCache();
+
+    function drop(i, req) {
+      req.readyState !== 4 && req.response(fixtures.ajaxResps.ok);
+    }
+  });
+
+  it('should use jQuery.ajax as the default transport mechanism', function() {
+    var req, resp = fixtures.ajaxResps.ok, spy = jasmine.createSpy();
+
+    this.transport.get('/test', spy);
+
+    req = mostRecentAjaxRequest();
+    req.response(resp);
+
+    expect(req.url).toBe('/test');
+    expect(spy).toHaveBeenCalledWith(null, resp.parsed);
+  });
+
+  it('should allow the transport mechanism to be configured', function() {
+    var resp = fixtures.ajaxResps.ok,
+        cbSpy = jasmine.createSpy(),
+        sendSpy = jasmine.createSpy().andCallFake(send);
+
+    this.transport = new Transport({ transport: sendSpy });
+    this.transport.get('/test', cbSpy);
+
+    jasmine.Clock.tick(0);
+
+    expect(cbSpy).toHaveBeenCalledWith(null, resp.parsed);
+    expect(sendSpy).toHaveBeenCalledWith(
+      '/test',
+      {},
+      jasmine.any(Function),
+      jasmine.any(Function)
+    );
+
+    // send must be async
+    function send(url, o, onSuccess, onError) { onSuccess(resp.parsed); }
+  });
+
+  it('should respect maxPendingRequests configuration', function() {
+    for (var i = 0; i < 10; i++) {
+      this.transport.get('/test' + i, $.noop);
+    }
+
+    expect(ajaxRequests.length).toBe(6);
+  });
+
+  it('should support rate limiting', function() {
+    this.transport = new Transport({ rateLimiter: rateLimiter });
+
+    for (var i = 0; i < 5; i++) {
+      this.transport.get('/test' + i, $.noop);
+    }
+
+    jasmine.Clock.tick(100);
+    expect(ajaxRequests.length).toBe(1);
+
+    function rateLimiter(fn) { return _.debounce(fn, 20); }
+  });
+
+  it('should cache most recent requests', function() {
+    var spy1 = jasmine.createSpy(), spy2 = jasmine.createSpy();
+
+    this.transport.get('/test1', $.noop);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+    this.transport.get('/test2', $.noop);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok1);
+
+    expect(ajaxRequests.length).toBe(2);
+
+    this.transport.get('/test1', spy1);
+    this.transport.get('/test2', spy2);
+
+    jasmine.Clock.tick(0);
+
+    // no ajax requests were made on subsequent requests
+    expect(ajaxRequests.length).toBe(2);
+
+    expect(spy1).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed);
+    expect(spy2).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok1.parsed);
+  });
+
+  it('should not cache requests if cache option is false', function() {
+    this.transport = new Transport({ cache: false });
+
+    this.transport.get('/test1', $.noop);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+    this.transport.get('/test1', $.noop);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+    expect(ajaxRequests.length).toBe(2);
+  });
+
+  it('should prevent dog pile', function() {
+    var spy1 = jasmine.createSpy(), spy2 = jasmine.createSpy();
+
+    this.transport.get('/test1', spy1);
+    this.transport.get('/test1', spy2);
+
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+    expect(ajaxRequests.length).toBe(1);
+
+    waitsFor(function() { return spy1.callCount && spy2.callCount; });
+
+    runs(function() {
+      expect(spy1).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed);
+      expect(spy2).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed);
+    });
+  });
+
+  it('should always make a request for the last call to #get', function() {
+    var spy = jasmine.createSpy();
+
+    for (var i = 0; i < 6; i++) {
+      this.transport.get('/test' + i, $.noop);
+    }
+
+    this.transport.get('/test' + i, spy);
+    expect(ajaxRequests.length).toBe(6);
+
+    _.each(ajaxRequests, function(req) {
+      req.response(fixtures.ajaxResps.ok);
+    });
+
+    expect(ajaxRequests.length).toBe(7);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('should invoke the callback with err set to true on failure', function() {
+    var req, resp = fixtures.ajaxResps.err, spy = jasmine.createSpy();
+
+    this.transport.get('/test', spy);
+
+    req = mostRecentAjaxRequest();
+    req.response(resp);
+
+    expect(req.url).toBe('/test');
+    expect(spy).toHaveBeenCalledWith(true);
+  });
+
+  it('should not send cancelled requests', function() {
+    this.transport = new Transport({ rateLimiter: rateLimiter });
+
+    this.transport.get('/test', $.noop);
+    this.transport.cancel();
+
+    jasmine.Clock.tick(100);
+    expect(ajaxRequests.length).toBe(0);
+
+    function rateLimiter(fn) { return _.debounce(fn, 20); }
+  });
+
+  it('should not send outdated requests', function() {
+    this.transport = new Transport({ rateLimiter: rateLimiter });
+
+    // warm cache
+    this.transport.get('/test1', $.noop);
+    jasmine.Clock.tick(100);
+    mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+    expect(mostRecentAjaxRequest().url).toBe('/test1');
+    expect(ajaxRequests.length).toBe(1);
+
+    // within the same rate-limit cycle, request test2 and test1. test2 becomes
+    // outdated after test1 is requested and no request is sent for test1
+    // because it's a cache hit
+    this.transport.get('/test2', $.noop);
+    this.transport.get('/test1', $.noop);
+
+    jasmine.Clock.tick(100);
+
+    expect(ajaxRequests.length).toBe(1);
+
+    function rateLimiter(fn) { return _.debounce(fn, 20); }
+  });
+});

data/vendor/assets/bower_components/typeahead.js/test/typeahead_view_spec.js

@@ -0,0 +1,570 @@
+describe('Typeahead', function() {
+  var testDatum;
+
+  beforeEach(function() {
+    var $fixture, $input;
+
+    jasmine.Input.useMock();
+    jasmine.Dataset.useMock();
+    jasmine.Dropdown.useMock();
+
+    setFixtures(fixtures.html.textInput);
+
+    $fixture = $('#jasmine-fixtures');
+    this.$input = $fixture.find('input');
+
+    testDatum = fixtures.data.simple[0];
+
+    this.view = new Typeahead({
+      input: this.$input,
+      withHint: true,
+      datasets: {}
+    });
+
+    this.input = this.view.input;
+    this.dropdown = this.view.dropdown;
+  });
+
+  describe('when dropdown triggers suggestionClicked', function() {
+    beforeEach(function() {
+      this.dropdown.getDatumForSuggestion.andReturn(testDatum);
+    });
+
+    it('should select the datum', function() {
+      var $e, spy;
+
+      this.$input.on('typeahead:selected', spy = jasmine.createSpy());
+      this.dropdown.trigger('suggestionClicked');
+
+      expect(spy).toHaveBeenCalled();
+      expect(this.input.setQuery).toHaveBeenCalledWith(testDatum.value);
+      expect(this.input.setInputValue)
+      .toHaveBeenCalledWith(testDatum.value, true);
+
+      waitsFor(function() { return this.dropdown.close.callCount; });
+    });
+  });
+
+  describe('when dropdown triggers cursorMoved', function() {
+    beforeEach(function() {
+      this.dropdown.getDatumForCursor.andReturn(testDatum);
+    });
+
+    it('should update the input value', function() {
+      this.dropdown.trigger('cursorMoved');
+
+      expect(this.input.setInputValue)
+      .toHaveBeenCalledWith(testDatum.value, true);
+    });
+
+    it('should trigger cursorchanged', function() {
+      var spy;
+
+      this.$input.on('typeahead:cursorchanged', spy = jasmine.createSpy());
+
+      this.dropdown.trigger('cursorMoved');
+
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when dropdown triggers cursorRemoved', function() {
+    it('should reset the input value', function() {
+      this.dropdown.trigger('cursorRemoved');
+
+      expect(this.input.resetInputValue).toHaveBeenCalled();
+    });
+
+    it('should update the hint', function() {
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.dropdown.isVisible.andReturn(true);
+      this.input.hasOverflow.andReturn(false);
+      this.input.getInputValue.andReturn(testDatum.value.slice(0, 2));
+
+      this.dropdown.trigger('cursorRemoved');
+
+      expect(this.input.setHint).toHaveBeenCalledWith(testDatum.value);
+    });
+  });
+
+  describe('when dropdown triggers datasetRendered', function() {
+    it('should update the hint asynchronously', function() {
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.dropdown.isVisible.andReturn(true);
+      this.input.hasOverflow.andReturn(false);
+      this.input.getInputValue.andReturn(testDatum.value.slice(0, 2));
+
+      this.dropdown.trigger('datasetRendered');
+
+      // ensure it wasn't called synchronously
+      expect(this.input.setHint).not.toHaveBeenCalled();
+
+      waitsFor(function() {
+        return !!this.input.setHint.callCount;
+      });
+
+      runs(function() {
+        expect(this.input.setHint).toHaveBeenCalledWith(testDatum.value);
+      });
+    });
+  });
+
+  describe('when dropdown triggers opened', function() {
+    it('should update the hint', function() {
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.dropdown.isVisible.andReturn(true);
+      this.input.hasOverflow.andReturn(false);
+      this.input.getInputValue.andReturn(testDatum.value.slice(0, 2));
+
+      this.dropdown.trigger('opened');
+
+      expect(this.input.setHint).toHaveBeenCalledWith(testDatum.value);
+    });
+
+    it('should trigger typeahead:opened', function() {
+      var spy;
+
+      this.$input.on('typeahead:opened', spy = jasmine.createSpy());
+
+      this.dropdown.trigger('opened');
+
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when dropdown triggers closed', function() {
+    it('should clear the hint', function() {
+      this.dropdown.trigger('closed');
+
+      expect(this.input.clearHint).toHaveBeenCalled();
+    });
+
+    it('should trigger typeahead:closed', function() {
+      var spy;
+
+      this.$input.on('typeahead:closed', spy = jasmine.createSpy());
+
+      this.dropdown.trigger('closed');
+
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers focused', function() {
+    it('should activate the typeahead', function() {
+      this.input.trigger('focused');
+
+      expect(this.view.isActivated).toBe(true);
+    });
+
+    it('should open the dropdown', function() {
+      this.input.trigger('focused');
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers blurred', function() {
+    it('should deactivate the typeahead', function() {
+      this.input.trigger('blurred');
+
+      expect(this.view.isActivated).toBe(false);
+    });
+
+    it('should empty the dropdown', function() {
+      this.input.trigger('blurred');
+
+      expect(this.dropdown.empty).toHaveBeenCalled();
+    });
+
+    it('should close the dropdown', function() {
+      this.input.trigger('blurred');
+
+      expect(this.dropdown.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers enterKeyed', function() {
+    beforeEach(function() {
+      this.dropdown.getDatumForCursor.andReturn(testDatum);
+    });
+
+    it('should select the datum', function() {
+      var $e, spy;
+
+      $e = jasmine.createSpyObj('event', ['preventDefault']);
+      this.$input.on('typeahead:selected', spy = jasmine.createSpy());
+      this.input.trigger('enterKeyed', $e);
+
+      expect(spy).toHaveBeenCalled();
+      expect(this.input.setQuery).toHaveBeenCalledWith(testDatum.value);
+      expect(this.input.setInputValue)
+      .toHaveBeenCalledWith(testDatum.value, true);
+
+      waitsFor(function() { return this.dropdown.close.callCount; });
+    });
+
+    it('should prevent the default behavior of the event', function() {
+      var $e;
+
+      $e = jasmine.createSpyObj('event', ['preventDefault']);
+      this.input.trigger('enterKeyed', $e);
+
+      expect($e.preventDefault).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers tabKeyed', function() {
+    describe('when cursor is in use', function() {
+      beforeEach(function() {
+        this.dropdown.getDatumForCursor.andReturn(testDatum);
+      });
+
+      it('should select the datum', function() {
+        var $e, spy;
+
+        $e = jasmine.createSpyObj('event', ['preventDefault']);
+        this.$input.on('typeahead:selected', spy = jasmine.createSpy());
+        this.input.trigger('tabKeyed', $e);
+
+        expect(spy).toHaveBeenCalled();
+        expect(this.input.setQuery).toHaveBeenCalledWith(testDatum.value);
+        expect(this.input.setInputValue)
+        .toHaveBeenCalledWith(testDatum.value, true);
+
+        waitsFor(function() { return this.dropdown.close.callCount; });
+      });
+
+      it('should prevent the default behavior of the event', function() {
+        var $e;
+
+        $e = jasmine.createSpyObj('event', ['preventDefault']);
+        this.input.trigger('tabKeyed', $e);
+
+        expect($e.preventDefault).toHaveBeenCalled();
+      });
+    });
+
+    describe('when cursor is not in use', function() {
+      it('should autocomplete', function() {
+        var spy;
+
+        this.input.getQuery.andReturn('bi');
+        this.input.getHint.andReturn(testDatum.value);
+        this.input.isCursorAtEnd.andReturn(true);
+        this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+        this.$input.on('typeahead:autocompleted', spy = jasmine.createSpy());
+
+        this.input.trigger('tabKeyed');
+
+        expect(this.input.setInputValue).toHaveBeenCalledWith(testDatum.value);
+        expect(spy).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('when input triggers escKeyed', function() {
+    it('should close the dropdown', function() {
+      this.input.trigger('escKeyed');
+
+      expect(this.dropdown.close).toHaveBeenCalled();
+    });
+
+    it('should reset the input value', function() {
+      this.input.trigger('escKeyed');
+
+      expect(this.input.resetInputValue).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers upKeyed', function() {
+    beforeEach(function() {
+      this.input.getQuery.andReturn('ghost');
+    });
+
+    describe('when dropdown is empty and minLength is satisfied', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = true;
+        this.view.minLength = 2;
+
+        this.input.trigger('upKeyed');
+      });
+
+      it('should update dropdown', function() {
+        expect(this.dropdown.update).toHaveBeenCalledWith('ghost');
+      });
+
+      it('should not move cursor up', function() {
+        expect(this.dropdown.moveCursorUp).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when dropdown is not empty', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = false;
+        this.view.minLength = 2;
+
+        this.input.trigger('upKeyed');
+      });
+
+      it('should not update dropdown', function() {
+        expect(this.dropdown.update).not.toHaveBeenCalled();
+      });
+
+      it('should move cursor up', function() {
+        expect(this.dropdown.moveCursorUp).toHaveBeenCalled();
+      });
+    });
+
+    describe('when minLength is not satisfied', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = true;
+        this.view.minLength = 10;
+
+        this.input.trigger('upKeyed');
+      });
+
+      it('should not update dropdown', function() {
+        expect(this.dropdown.update).not.toHaveBeenCalled();
+      });
+
+      it('should move cursor up', function() {
+        expect(this.dropdown.moveCursorUp).toHaveBeenCalled();
+      });
+    });
+
+    it('should open the dropdown', function() {
+      this.input.trigger('upKeyed');
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers downKeyed', function() {
+    beforeEach(function() {
+      this.input.getQuery.andReturn('ghost');
+    });
+
+    describe('when dropdown is empty and minLength is satisfied', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = true;
+        this.view.minLength = 2;
+
+        this.input.trigger('downKeyed');
+      });
+
+      it('should update dropdown', function() {
+        expect(this.dropdown.update).toHaveBeenCalledWith('ghost');
+      });
+
+      it('should not move cursor down', function() {
+        expect(this.dropdown.moveCursorDown).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when dropdown is not empty', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = false;
+        this.view.minLength = 2;
+
+        this.input.trigger('downKeyed');
+      });
+
+      it('should not update dropdown', function() {
+        expect(this.dropdown.update).not.toHaveBeenCalled();
+      });
+
+      it('should move cursor down', function() {
+        expect(this.dropdown.moveCursorDown).toHaveBeenCalled();
+      });
+    });
+
+    describe('when minLength is not satisfied', function() {
+      beforeEach(function() {
+        this.dropdown.isEmpty = true;
+        this.view.minLength = 10;
+
+        this.input.trigger('downKeyed');
+      });
+
+      it('should not update dropdown', function() {
+        expect(this.dropdown.update).not.toHaveBeenCalled();
+      });
+
+      it('should move cursor down', function() {
+        expect(this.dropdown.moveCursorDown).toHaveBeenCalled();
+      });
+    });
+
+    it('should open the dropdown', function() {
+      this.input.trigger('downKeyed');
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers leftKeyed', function() {
+    it('should autocomplete if language is rtl', function() {
+      var spy;
+
+      this.view.dir = 'rtl';
+      this.input.getQuery.andReturn('bi');
+      this.input.getHint.andReturn(testDatum.value);
+      this.input.isCursorAtEnd.andReturn(true);
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.$input.on('typeahead:autocompleted', spy = jasmine.createSpy());
+
+      this.input.trigger('leftKeyed');
+
+      expect(this.input.setInputValue).toHaveBeenCalledWith(testDatum.value);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers rightKeyed', function() {
+    it('should autocomplete if language is ltr', function() {
+      var spy;
+
+      this.view.dir = 'ltr';
+      this.input.getQuery.andReturn('bi');
+      this.input.getHint.andReturn(testDatum.value);
+      this.input.isCursorAtEnd.andReturn(true);
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.$input.on('typeahead:autocompleted', spy = jasmine.createSpy());
+
+      this.input.trigger('rightKeyed');
+
+      expect(this.input.setInputValue).toHaveBeenCalledWith(testDatum.value);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when input triggers queryChanged', function() {
+    it('should clear the hint if it has become invalid', function() {
+      this.input.trigger('queryChanged', testDatum.value);
+
+      expect(this.input.clearHintIfInvalid).toHaveBeenCalled();
+    });
+
+    it('should empty dropdown if the query is empty', function() {
+      this.input.trigger('queryChanged', '');
+
+      expect(this.dropdown.empty).toHaveBeenCalled();
+    });
+
+    it('should not empty dropdown if the query is non-empty', function() {
+      this.input.trigger('queryChanged', testDatum.value);
+
+      expect(this.dropdown.empty).not.toHaveBeenCalled();
+    });
+
+    it('should update dropdown', function() {
+      this.input.trigger('queryChanged', testDatum.value);
+
+      expect(this.dropdown.update).toHaveBeenCalledWith(testDatum.value);
+    });
+
+    it('should open the dropdown', function() {
+      this.input.trigger('queryChanged', testDatum.value);
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+
+    it('should set the language direction', function() {
+      this.input.getLanguageDirection.andReturn('rtl');
+
+      this.input.trigger('queryChanged', testDatum.value);
+
+      expect(this.view.dir).toBe('rtl');
+      expect(this.view.$node).toHaveCss({ direction: 'rtl' });
+      expect(this.dropdown.setLanguageDirection).toHaveBeenCalledWith('rtl');
+    });
+  });
+
+  describe('when input triggers whitespaceChanged', function() {
+    it('should update the hint', function() {
+      this.dropdown.getDatumForTopSuggestion.andReturn(testDatum);
+      this.dropdown.isVisible.andReturn(true);
+      this.input.hasOverflow.andReturn(false);
+      this.input.getInputValue.andReturn(testDatum.value.slice(0, 2));
+
+      this.input.trigger('whitespaceChanged');
+
+      expect(this.input.setHint).toHaveBeenCalledWith(testDatum.value);
+    });
+
+    it('should open the dropdown', function() {
+      this.input.trigger('whitespaceChanged');
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+  });
+
+  describe('#open', function() {
+    it('should open the dropdown', function() {
+      this.view.open();
+
+      expect(this.dropdown.open).toHaveBeenCalled();
+    });
+  });
+
+  describe('#close', function() {
+    it('should close the dropdown', function() {
+      this.view.close();
+
+      expect(this.dropdown.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('#getVal', function() {
+    it('should return the current query', function() {
+      this.input.getQuery.andReturn('woah');
+      this.view.close();
+
+      expect(this.view.getVal()).toBe('woah');
+    });
+  });
+
+  describe('#setVal', function() {
+    it('should update query', function() {
+      this.view.isActivated = true;
+      this.view.setVal('woah');
+
+      expect(this.input.setInputValue).toHaveBeenCalledWith('woah');
+    });
+
+    it('should update query silently if not activated', function() {
+      this.view.setVal('woah');
+
+      expect(this.input.setQuery).toHaveBeenCalledWith('woah');
+      expect(this.input.setInputValue).toHaveBeenCalledWith('woah', true);
+    });
+  });
+
+  describe('#destroy', function() {
+    it('should destroy input', function() {
+      this.view.destroy();
+
+      expect(this.input.destroy).toHaveBeenCalled();
+    });
+
+    it('should destroy dropdown', function() {
+      this.view.destroy();
+
+      expect(this.dropdown.destroy).toHaveBeenCalled();
+    });
+
+    it('should null out its reference to the wrapper element', function() {
+      this.view.destroy();
+
+      expect(this.view.$node).toBeNull();
+    });
+
+    it('should revert DOM changes', function() {
+      this.view.destroy();
+
+      // TODO: bad test
+      expect(this.$input).not.toHaveClass('tt-input');
+    });
+  });
+});