iqvoc 4.8.1 → 4.8.2

data/vendor/assets/bower_components/typeahead.js/src/typeahead/typeahead.js

@@ -0,0 +1,391 @@
+/*
+ * typeahead.js
+ * https://github.com/twitter/typeahead.js
+ * Copyright 2013-2014 Twitter, Inc. and other contributors; Licensed MIT
+ */
+
+var Typeahead = (function() {
+  'use strict';
+
+  var attrsKey = 'ttAttrs';
+
+  // constructor
+  // -----------
+
+  // THOUGHT: what if datasets could dynamically be added/removed?
+  function Typeahead(o) {
+    var $menu, $input, $hint;
+
+    o = o || {};
+
+    if (!o.input) {
+      $.error('missing input');
+    }
+
+    this.isActivated = false;
+    this.autoselect = !!o.autoselect;
+    this.minLength = _.isNumber(o.minLength) ? o.minLength : 1;
+    this.$node = buildDom(o.input, o.withHint);
+
+    $menu = this.$node.find('.tt-dropdown-menu');
+    $input = this.$node.find('.tt-input');
+    $hint = this.$node.find('.tt-hint');
+
+    // #705: if there's scrollable overflow, ie doesn't support
+    // blur cancellations when the scrollbar is clicked
+    //
+    // #351: preventDefault won't cancel blurs in ie <= 8
+    $input.on('blur.tt', function($e) {
+      var active, isActive, hasActive;
+
+      active = document.activeElement;
+      isActive = $menu.is(active);
+      hasActive = $menu.has(active).length > 0;
+
+      if (_.isMsie() && (isActive || hasActive)) {
+        $e.preventDefault();
+        // stop immediate in order to prevent Input#_onBlur from
+        // getting exectued
+        $e.stopImmediatePropagation();
+        _.defer(function() { $input.focus(); });
+      }
+    });
+
+    // #351: prevents input blur due to clicks within dropdown menu
+    $menu.on('mousedown.tt', function($e) { $e.preventDefault(); });
+
+    this.eventBus = o.eventBus || new EventBus({ el: $input });
+
+    this.dropdown = new Dropdown({ menu: $menu, datasets: o.datasets })
+    .onSync('suggestionClicked', this._onSuggestionClicked, this)
+    .onSync('cursorMoved', this._onCursorMoved, this)
+    .onSync('cursorRemoved', this._onCursorRemoved, this)
+    .onSync('opened', this._onOpened, this)
+    .onSync('closed', this._onClosed, this)
+    .onAsync('datasetRendered', this._onDatasetRendered, this);
+
+    this.input = new Input({ input: $input, hint: $hint })
+    .onSync('focused', this._onFocused, this)
+    .onSync('blurred', this._onBlurred, this)
+    .onSync('enterKeyed', this._onEnterKeyed, this)
+    .onSync('tabKeyed', this._onTabKeyed, this)
+    .onSync('escKeyed', this._onEscKeyed, this)
+    .onSync('upKeyed', this._onUpKeyed, this)
+    .onSync('downKeyed', this._onDownKeyed, this)
+    .onSync('leftKeyed', this._onLeftKeyed, this)
+    .onSync('rightKeyed', this._onRightKeyed, this)
+    .onSync('queryChanged', this._onQueryChanged, this)
+    .onSync('whitespaceChanged', this._onWhitespaceChanged, this);
+
+    this._setLanguageDirection();
+  }
+
+  // instance methods
+  // ----------------
+
+  _.mixin(Typeahead.prototype, {
+
+    // ### private
+
+    _onSuggestionClicked: function onSuggestionClicked(type, $el) {
+      var datum;
+
+      if (datum = this.dropdown.getDatumForSuggestion($el)) {
+        this._select(datum);
+      }
+    },
+
+    _onCursorMoved: function onCursorMoved() {
+      var datum = this.dropdown.getDatumForCursor();
+
+      this.input.setInputValue(datum.value, true);
+
+      this.eventBus.trigger('cursorchanged', datum.raw, datum.datasetName);
+    },
+
+    _onCursorRemoved: function onCursorRemoved() {
+      this.input.resetInputValue();
+      this._updateHint();
+    },
+
+    _onDatasetRendered: function onDatasetRendered() {
+      this._updateHint();
+    },
+
+    _onOpened: function onOpened() {
+      this._updateHint();
+
+      this.eventBus.trigger('opened');
+    },
+
+    _onClosed: function onClosed() {
+      this.input.clearHint();
+
+      this.eventBus.trigger('closed');
+    },
+
+    _onFocused: function onFocused() {
+      this.isActivated = true;
+      this.dropdown.open();
+    },
+
+    _onBlurred: function onBlurred() {
+      this.isActivated = false;
+      this.dropdown.empty();
+      this.dropdown.close();
+    },
+
+    _onEnterKeyed: function onEnterKeyed(type, $e) {
+      var cursorDatum, topSuggestionDatum;
+
+      cursorDatum = this.dropdown.getDatumForCursor();
+      topSuggestionDatum = this.dropdown.getDatumForTopSuggestion();
+
+      if (cursorDatum) {
+        this._select(cursorDatum);
+        $e.preventDefault();
+      }
+
+      else if (this.autoselect && topSuggestionDatum) {
+        this._select(topSuggestionDatum);
+        $e.preventDefault();
+      }
+    },
+
+    _onTabKeyed: function onTabKeyed(type, $e) {
+      var datum;
+
+      if (datum = this.dropdown.getDatumForCursor()) {
+        this._select(datum);
+        $e.preventDefault();
+      }
+
+      else {
+        this._autocomplete(true);
+      }
+    },
+
+    _onEscKeyed: function onEscKeyed() {
+      this.dropdown.close();
+      this.input.resetInputValue();
+    },
+
+    _onUpKeyed: function onUpKeyed() {
+      var query = this.input.getQuery();
+
+      this.dropdown.isEmpty && query.length >= this.minLength ?
+        this.dropdown.update(query) :
+        this.dropdown.moveCursorUp();
+
+      this.dropdown.open();
+    },
+
+    _onDownKeyed: function onDownKeyed() {
+      var query = this.input.getQuery();
+
+      this.dropdown.isEmpty && query.length >= this.minLength ?
+        this.dropdown.update(query) :
+        this.dropdown.moveCursorDown();
+
+      this.dropdown.open();
+    },
+
+    _onLeftKeyed: function onLeftKeyed() {
+      this.dir === 'rtl' && this._autocomplete();
+    },
+
+    _onRightKeyed: function onRightKeyed() {
+      this.dir === 'ltr' && this._autocomplete();
+    },
+
+    _onQueryChanged: function onQueryChanged(e, query) {
+      this.input.clearHintIfInvalid();
+
+      query.length >= this.minLength ?
+        this.dropdown.update(query) :
+        this.dropdown.empty();
+
+      this.dropdown.open();
+      this._setLanguageDirection();
+    },
+
+    _onWhitespaceChanged: function onWhitespaceChanged() {
+      this._updateHint();
+      this.dropdown.open();
+    },
+
+    _setLanguageDirection: function setLanguageDirection() {
+      var dir;
+
+      if (this.dir !== (dir = this.input.getLanguageDirection())) {
+        this.dir = dir;
+        this.$node.css('direction', dir);
+        this.dropdown.setLanguageDirection(dir);
+      }
+    },
+
+    _updateHint: function updateHint() {
+      var datum, val, query, escapedQuery, frontMatchRegEx, match;
+
+      datum = this.dropdown.getDatumForTopSuggestion();
+
+      if (datum && this.dropdown.isVisible() && !this.input.hasOverflow()) {
+        val = this.input.getInputValue();
+        query = Input.normalizeQuery(val);
+        escapedQuery = _.escapeRegExChars(query);
+
+        // match input value, then capture trailing text
+        frontMatchRegEx = new RegExp('^(?:' + escapedQuery + ')(.+$)', 'i');
+        match = frontMatchRegEx.exec(datum.value);
+
+        // clear hint if there's no trailing text
+        match ? this.input.setHint(val + match[1]) : this.input.clearHint();
+      }
+
+      else {
+        this.input.clearHint();
+      }
+    },
+
+    _autocomplete: function autocomplete(laxCursor) {
+      var hint, query, isCursorAtEnd, datum;
+
+      hint = this.input.getHint();
+      query = this.input.getQuery();
+      isCursorAtEnd = laxCursor || this.input.isCursorAtEnd();
+
+      if (hint && query !== hint && isCursorAtEnd) {
+        datum = this.dropdown.getDatumForTopSuggestion();
+        datum && this.input.setInputValue(datum.value);
+
+        this.eventBus.trigger('autocompleted', datum.raw, datum.datasetName);
+      }
+    },
+
+    _select: function select(datum) {
+      this.input.setQuery(datum.value);
+      this.input.setInputValue(datum.value, true);
+
+      this._setLanguageDirection();
+
+      this.eventBus.trigger('selected', datum.raw, datum.datasetName);
+      this.dropdown.close();
+
+      // #118: allow click event to bubble up to the body before removing
+      // the suggestions otherwise we break event delegation
+      _.defer(_.bind(this.dropdown.empty, this.dropdown));
+    },
+
+    // ### public
+
+    open: function open() {
+      this.dropdown.open();
+    },
+
+    close: function close() {
+      this.dropdown.close();
+    },
+
+    setVal: function setVal(val) {
+      // expect val to be a string, so be safe, and coerce
+      val = _.toStr(val);
+
+      if (this.isActivated) {
+        this.input.setInputValue(val);
+      }
+
+      else {
+        this.input.setQuery(val);
+        this.input.setInputValue(val, true);
+      }
+
+      this._setLanguageDirection();
+    },
+
+    getVal: function getVal() {
+      return this.input.getQuery();
+    },
+
+    destroy: function destroy() {
+      this.input.destroy();
+      this.dropdown.destroy();
+
+      destroyDomStructure(this.$node);
+
+      this.$node = null;
+    }
+  });
+
+  return Typeahead;
+
+  function buildDom(input, withHint) {
+    var $input, $wrapper, $dropdown, $hint;
+
+    $input = $(input);
+    $wrapper = $(html.wrapper).css(css.wrapper);
+    $dropdown = $(html.dropdown).css(css.dropdown);
+    $hint = $input.clone().css(css.hint).css(getBackgroundStyles($input));
+
+    $hint
+    .val('')
+    .removeData()
+    .addClass('tt-hint')
+    .removeAttr('id name placeholder required')
+    .prop('readonly', true)
+    .attr({ autocomplete: 'off', spellcheck: 'false', tabindex: -1 });
+
+    // store the original values of the attrs that get modified
+    // so modifications can be reverted on destroy
+    $input.data(attrsKey, {
+      dir: $input.attr('dir'),
+      autocomplete: $input.attr('autocomplete'),
+      spellcheck: $input.attr('spellcheck'),
+      style: $input.attr('style')
+    });
+
+    $input
+    .addClass('tt-input')
+    .attr({ autocomplete: 'off', spellcheck: false })
+    .css(withHint ? css.input : css.inputWithNoHint);
+
+    // ie7 does not like it when dir is set to auto
+    try { !$input.attr('dir') && $input.attr('dir', 'auto'); } catch (e) {}
+
+    return $input
+    .wrap($wrapper)
+    .parent()
+    .prepend(withHint ? $hint : null)
+    .append($dropdown);
+  }
+
+  function getBackgroundStyles($el) {
+    return {
+      backgroundAttachment: $el.css('background-attachment'),
+      backgroundClip: $el.css('background-clip'),
+      backgroundColor: $el.css('background-color'),
+      backgroundImage: $el.css('background-image'),
+      backgroundOrigin: $el.css('background-origin'),
+      backgroundPosition: $el.css('background-position'),
+      backgroundRepeat: $el.css('background-repeat'),
+      backgroundSize: $el.css('background-size')
+    };
+  }
+
+  function destroyDomStructure($node) {
+    var $input = $node.find('.tt-input');
+
+    // need to remove attrs that weren't previously defined and
+    // revert attrs that originally had a value
+    _.each($input.data(attrsKey), function(val, key) {
+      _.isUndefined(val) ? $input.removeAttr(key) : $input.attr(key, val);
+    });
+
+    $input
+    .detach()
+    .removeData(attrsKey)
+    .removeClass('tt-input')
+    .insertAfter($node);
+
+    $node.remove();
+  }
+})();

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

@@ -0,0 +1,592 @@
+describe('Bloodhound', function() {
+
+  beforeEach(function() {
+    jasmine.Ajax.useMock();
+    jasmine.Transport.useMock();
+    jasmine.PersistentStorage.useMock();
+  });
+
+  afterEach(function() {
+    clearAjaxRequests();
+  });
+
+  describe('#initialize', function() {
+    beforeEach(function() {
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        local: fixtures.data.simple
+      });
+
+      spyOn(this.bloodhound, '_initialize').andCallThrough();
+    });
+
+    it('should not support reinitialization by default', function() {
+      var p1, p2;
+
+      p1 = this.bloodhound.initialize();
+      p2 = this.bloodhound.initialize();
+
+      expect(p1).toBe(p2);
+      expect(this.bloodhound._initialize.callCount).toBe(1);
+    });
+
+    it('should reinitialize if reintialize flag is true', function() {
+      var p1, p2;
+
+      p1 = this.bloodhound.initialize();
+      p2 = this.bloodhound.initialize(true);
+
+      expect(p1).not.toBe(p2);
+      expect(this.bloodhound._initialize.callCount).toBe(2);
+    });
+  });
+
+  describe('#add', function() {
+    it('should add datums to search index', function() {
+      var spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        local: []
+      });
+      this.bloodhound.initialize();
+      this.bloodhound.add(fixtures.data.simple);
+
+      this.bloodhound.get('big', spy);
+
+      expect(spy).toHaveBeenCalledWith([
+        { value: 'big' },
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+    });
+  });
+
+  describe('#clear', function() {
+    it('should remove all datums to search index', function() {
+      var spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        local: fixtures.data.simple
+      });
+      this.bloodhound.initialize();
+      this.bloodhound.clear();
+
+      this.bloodhound.get('big', spy);
+
+      expect(spy).toHaveBeenCalledWith([]);
+    });
+  });
+
+  describe('#clearPrefetchCache', function() {
+    it('should clear persistent storage', function() {
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: '/test'
+      });
+      this.bloodhound.initialize();
+      this.bloodhound.clearPrefetchCache();
+
+      expect(this.bloodhound.storage.clear).toHaveBeenCalled();
+    });
+  });
+
+  describe('#clearRemoteCache', function() {
+    it('should clear remote request cache', function() {
+      spyOn(Transport, 'resetCache');
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        remote: '/test'
+      });
+      this.bloodhound.initialize();
+
+      this.bloodhound.clearRemoteCache();
+      expect(Transport.resetCache).toHaveBeenCalled();
+    });
+  });
+
+  describe('local', function() {
+    describe('when local is an array', function() {
+      beforeEach(function() {
+        this.bloodhound = new Bloodhound({
+          datumTokenizer: datumTokenizer,
+          queryTokenizer: queryTokenizer,
+          local: fixtures.data.simple
+        });
+
+        this.bloodhound.initialize();
+      });
+
+      it('should hydrate the bloodhound', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.get('big', spy);
+
+        expect(spy).toHaveBeenCalledWith([
+          { value: 'big' },
+          { value: 'bigger' },
+          { value: 'biggest' }
+        ]);
+      });
+    });
+
+    describe('when local is a function that returns an array', function() {
+      beforeEach(function() {
+        var localFn = function() {
+          return fixtures.data.simple;
+        };
+
+        this.bloodhound = new Bloodhound({
+          datumTokenizer: datumTokenizer,
+          queryTokenizer: queryTokenizer,
+          local: localFn
+        });
+
+        this.bloodhound.initialize();
+      });
+
+      it('should hydrate the bloodhound', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.get('big', spy);
+
+        expect(spy).toHaveBeenCalledWith([
+          { value: 'big' },
+          { value: 'bigger' },
+          { value: 'biggest' }
+        ]);
+      });
+    });
+  });
+
+  describe('prefetch', function() {
+    it('should throw error if url is not set', function() {
+      expect(test).toThrow();
+
+      function test() { var d = new Bloodhound({ prefetch: {} }); }
+    });
+
+    it('should use url or cacheKey to store data locally', function() {
+      var ttl = 100;
+
+      this.bloodhound1 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: { url: '/test1', cacheKey: 'woah' }
+      });
+      expect(PersistentStorage).toHaveBeenCalledWith('woah');
+
+      this.bloodhound2 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: { url: '/test2', ttl: ttl, thumbprint: '!' }
+      });
+      expect(PersistentStorage).toHaveBeenCalledWith('/test2');
+
+      this.bloodhound2.initialize();
+      ajaxRequests[0].response(fixtures.ajaxResps.ok);
+
+      expect(this.bloodhound2.storage.set)
+        .toHaveBeenCalledWith('data', fixtures.serialized.simple, ttl);
+      expect(this.bloodhound2.storage.set)
+        .toHaveBeenCalledWith('protocol', 'http:', ttl);
+      expect(this.bloodhound2.storage.set)
+        .toHaveBeenCalledWith('thumbprint', '%VERSION%!', ttl);
+    });
+
+    it('should load data from provided url', function() {
+      var spy1, spy2;
+
+      spy1 = jasmine.createSpy();
+      spy2 = jasmine.createSpy();
+
+      this.bloodhound1 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: '/test1'
+      });
+      this.bloodhound2 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: { url: '/test2' }
+      });
+      this.bloodhound1.initialize();
+      this.bloodhound2.initialize();
+
+      ajaxRequests[0].response(fixtures.ajaxResps.ok);
+      ajaxRequests[1].response(fixtures.ajaxResps.ok);
+
+      expect(ajaxRequests[0].url).toBe('/test1');
+      expect(ajaxRequests[1].url).toBe('/test2');
+
+      this.bloodhound1.get('big', spy1);
+      this.bloodhound2.get('big', spy2);
+
+      expect(spy1).toHaveBeenCalledWith([
+        { value: 'big' },
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+
+      expect(spy2).toHaveBeenCalledWith([
+        { value: 'big' },
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+    });
+
+    it('should clear preexisting data', function() {
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: '/test'
+      });
+
+      spyOn(this.bloodhound, 'clear');
+      this.bloodhound.initialize();
+
+      mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+      expect(this.bloodhound.clear).toHaveBeenCalled();
+    });
+
+    it('should filter data if filter is provided', function() {
+      var filterSpy, spy;
+
+      filterSpy = jasmine.createSpy().andCallFake(fakeFilter);
+      spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: { url: '/test', filter: filterSpy }
+      });
+      this.bloodhound.initialize();
+
+      mostRecentAjaxRequest().response(fixtures.ajaxResps.ok);
+
+      expect(filterSpy).toHaveBeenCalled();
+
+      this.bloodhound.get('big', spy);
+
+      expect(spy).toHaveBeenCalledWith([
+        { value: 'BIG' },
+        { value: 'BIGGER' },
+        { value: 'BIGGEST' }
+      ]);
+
+      function fakeFilter(resp) {
+        return [{ value: 'BIG' }, { value: 'BIGGER' }, { value: 'BIGGEST' }];
+      }
+    });
+
+    it('should not make a request if data is available in storage', function() {
+      var that = this, spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        prefetch: '/test'
+      });
+      this.bloodhound.storage.get.andCallFake(fakeGet);
+      this.bloodhound.initialize();
+
+      expect(mostRecentAjaxRequest()).toBeNull();
+
+      this.bloodhound.get('big', spy);
+
+      expect(spy).toHaveBeenCalledWith([
+        { value: 'big' },
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+
+      function fakeGet(key) {
+        var val;
+
+        switch (key) {
+          case 'data':
+            val = fixtures.serialized.simple;
+            break;
+          case 'protocol':
+            val = 'http:';
+            break;
+          case 'thumbprint':
+            val = that.bloodhound.prefetch.thumbprint;
+            break;
+        }
+
+        return val;
+      }
+    });
+  });
+
+  describe('remote', function() {
+    it('should perform query substitution on the provided url', function() {
+      this.bloodhound1 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        remote: { url: '/test?q=$$', wildcard: '$$' }
+      });
+      this.bloodhound2 = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        remote: {
+          url: '/test?q=%QUERY',
+          replace: function(str, query) {return str.replace('%QUERY', query);  }
+        }
+      });
+
+      this.bloodhound1.initialize();
+      this.bloodhound2.initialize();
+
+      this.bloodhound1.get('one two', $.noop);
+      this.bloodhound2.get('one two', $.noop);
+
+      expect(this.bloodhound1.transport.get).toHaveBeenCalledWith(
+        '/test?q=one%20two',
+        { type: 'GET', dataType: 'json' },
+        jasmine.any(Function)
+      );
+
+      expect(this.bloodhound2.transport.get).toHaveBeenCalledWith(
+        '/test?q=one two',
+        { type: 'GET', dataType: 'json' },
+        jasmine.any(Function)
+      );
+    });
+
+    it('should filter the response if a filter is provided', function() {
+      var filterSpy, spy;
+
+      spy = jasmine.createSpy();
+      filterSpy = jasmine.createSpy().andCallFake(fakeFilter);
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        remote: { url: '/test', filter: filterSpy }
+      });
+      this.bloodhound.initialize();
+
+      this.bloodhound.transport.get.andCallFake(fakeGet);
+      this.bloodhound.get('big', spy);
+
+      waitsFor(function() { return spy.callCount; });
+
+      runs(function() {
+        expect(filterSpy).toHaveBeenCalled();
+
+        expect(spy).toHaveBeenCalledWith([
+          { value: 'BIG' },
+          { value: 'BIGGER' },
+          { value: 'BIGGEST' }
+        ]);
+      });
+
+      function fakeFilter(resp) {
+        return [{ value: 'BIG' }, { value: 'BIGGER' }, { value: 'BIGGEST' }];
+      }
+
+      function fakeGet(url, o, cb) {
+        cb(null, fixtures.data.simple);
+      }
+    });
+
+    describe('when there is not matching data in the search index', function() {
+      beforeEach(function() {
+        this.bloodhound = new Bloodhound({
+          datumTokenizer: datumTokenizer,
+          queryTokenizer: queryTokenizer,
+          remote: '/test?q=%QUERY',
+          local: { value: 'not an animal' }
+        });
+
+        this.bloodhound.initialize();
+      });
+
+      it('should call #get callback once if there is a cache hit', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.transport.get.andCallFake(fakeGetWithCacheHit);
+        this.bloodhound.get('dog', spy);
+
+        expect(spy.callCount).toBe(1);
+
+        function fakeGetWithCacheHit(url, o, cb) {
+          cb(null, fixtures.data.animals);
+          return true;
+        }
+      });
+
+      it('should call #get callback once if there is a cache miss', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.transport.get.andCallFake(fakeGetWithCacheMiss);
+        this.bloodhound.get('dog', spy);
+
+        expect(spy.callCount).toBe(1);
+
+        function fakeGetWithCacheMiss(url, o, cb) {
+          cb(null, fixtures.data.animals);
+          return false;
+        }
+      });
+
+    });
+
+    describe('when there is matching data in the search index', function() {
+      beforeEach(function() {
+        this.bloodhound = new Bloodhound({
+          datumTokenizer: datumTokenizer,
+          queryTokenizer: queryTokenizer,
+          remote: '/test?q=%QUERY',
+          local: { value: 'dog' }
+        });
+
+        this.bloodhound.initialize();
+      });
+
+      it('should call the #get callback twice if there is a cache miss', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.transport.get.andCallFake(fakeGetWithCacheMiss);
+        this.bloodhound.get('dog', spy);
+
+        expect(spy.callCount).toBe(2);
+
+        function fakeGetWithCacheMiss(url, o, cb) {
+          cb(null, fixtures.data.animals);
+          return false;
+        }
+      });
+
+      it('should call the #get callback once if there is a cache hit', function() {
+        var spy = jasmine.createSpy();
+
+        this.bloodhound.transport.get.andCallFake(fakeGetWithCacheHit);
+        this.bloodhound.get('dog', spy);
+
+        expect(spy.callCount).toBe(1);
+
+        function fakeGetWithCacheHit(url, o, cb) {
+          cb(null, fixtures.data.animals);
+          return true;
+        }
+      });
+    });
+
+    it('should should treat failures as empty suggestion sets', function() {
+      var spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        remote: '/test?q=%QUERY'
+      });
+      this.bloodhound.initialize();
+      this.bloodhound.transport.get.andCallFake(fakeGet);
+
+      this.bloodhound.get('dog', spy);
+
+      expect(spy).toHaveBeenCalledWith([]);
+
+      function fakeGet(url, o, cb) { cb(true); }
+    });
+  });
+
+  describe('local/prefetch/remote integration', function() {
+    it('duplicates should be removed if dupDetector is provided', function() {
+      var spy;
+
+      spy = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        limit: 6,
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        dupDetector: function(d1, d2) { return d1.value === d2.value; },
+        local: fixtures.data.animals,
+        remote: { url: '/test?q=%QUERY' }
+      });
+
+      this.bloodhound.initialize();
+
+      this.bloodhound.transport.get.andCallFake(fakeGet);
+
+      this.bloodhound.get('dog', spy);
+
+      expect(spy).toHaveBeenCalledWith([{ value: 'dog' }]);
+
+      waitsFor(function() { return spy.callCount === 2; });
+
+      runs(function() {
+        expect(spy).toHaveBeenCalledWith(fixtures.data.animals);
+      });
+
+      function fakeGet(url, o, cb) {
+        setTimeout(function() { cb(null, fixtures.data.animals); }, 0);
+      }
+    });
+
+    it('remote should backfill local/prefetch', function() {
+      var spy1, spy2;
+
+      spy1 = jasmine.createSpy();
+      spy2 = jasmine.createSpy();
+
+      this.bloodhound = new Bloodhound({
+        limit: 3,
+        datumTokenizer: datumTokenizer,
+        queryTokenizer: queryTokenizer,
+        local: fixtures.data.simple,
+        remote: { url: '/test?q=%QUERY' }
+      });
+      this.bloodhound.initialize();
+
+      this.bloodhound.transport.get.andCallFake(fakeGet);
+
+      this.bloodhound.get('big', spy1);
+      this.bloodhound.get('bigg', spy2);
+
+      expect(spy1.callCount).toBe(1);
+      expect(spy2.callCount).toBe(1);
+
+      expect(spy1).toHaveBeenCalledWith([
+        { value: 'big' },
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+      expect(spy2).toHaveBeenCalledWith([
+        { value: 'bigger' },
+        { value: 'biggest' }
+      ]);
+
+      waitsFor(function() { return spy2.callCount === 2; });
+
+      runs(function() {
+        expect(spy2).toHaveBeenCalledWith([
+          { value: 'bigger' },
+          { value: 'biggest' },
+          { value: 'dog' }
+        ]);
+      });
+
+      function fakeGet(url, o, cb) {
+        setTimeout(function() { cb(null, fixtures.data.animals); }, 0);
+      }
+    });
+  });
+
+  // helper functions
+  // ----------------
+
+  function datumTokenizer(d) { return $.trim(d.value).split(/\s+/); }
+  function queryTokenizer(s) { return $.trim(s).split(/\s+/); }
+});