iqvoc 4.8.1 → 4.8.2

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

@@ -0,0 +1,111 @@
+describe('EventEmitter', function() {
+
+  beforeEach(function() {
+    this.spy = jasmine.createSpy();
+    this.target = _.mixin({}, EventEmitter);
+  });
+
+  it('methods should be chainable', function() {
+    expect(this.target.onSync()).toEqual(this.target);
+    expect(this.target.onAsync()).toEqual(this.target);
+    expect(this.target.off()).toEqual(this.target);
+    expect(this.target.trigger()).toEqual(this.target);
+  });
+
+  it('#on should take the context a callback should be called in', function() {
+    var context = { val: 3 }, cbContext;
+
+    this.target.onSync('xevent', setCbContext, context).trigger('xevent');
+
+    waitsFor(assertCbContext, 'callback was called in the wrong context');
+
+    function setCbContext() { cbContext = this; }
+    function assertCbContext() { return cbContext === context; }
+  });
+
+  it('#onAsync callbacks should be invoked asynchronously', function() {
+    this.target.onAsync('event', this.spy).trigger('event');
+
+    expect(this.spy.callCount).toBe(0);
+    waitsFor(assertCallCount(this.spy, 1), 'the callback was not invoked');
+  });
+
+  it('#onSync callbacks should be invoked synchronously', function() {
+    this.target.onSync('event', this.spy).trigger('event');
+
+    expect(this.spy.callCount).toBe(1);
+  });
+
+  it('#off should remove callbacks', function() {
+    this.target
+    .onSync('event1 event2', this.spy)
+    .onAsync('event1 event2', this.spy)
+    .off('event1 event2')
+    .trigger('event1 event2');
+
+    waits(100);
+    runs(assertCallCount(this.spy, 0));
+  });
+
+  it('methods should accept multiple event types', function() {
+    this.target
+    .onSync('event1 event2', this.spy)
+    .onAsync('event1 event2', this.spy)
+    .trigger('event1 event2');
+
+    expect(this.spy.callCount).toBe(2);
+    waitsFor(assertCallCount(this.spy, 4), 'the callback was not invoked');
+  });
+
+  it('the event type should be passed to the callback', function() {
+    this.target
+    .onSync('sync', this.spy)
+    .onAsync('async', this.spy)
+    .trigger('sync async');
+
+    waitsFor(assertArgs(this.spy, 0, ['sync']), 'bad args');
+    waitsFor(assertArgs(this.spy, 1, ['async']), 'bad args');
+  });
+
+  it('arbitrary args should be passed to the callback', function() {
+    this.target
+    .onSync('event', this.spy)
+    .onAsync('event', this.spy)
+    .trigger('event', 1, 2);
+
+    waitsFor(assertArgs(this.spy, 0, ['event', 1, 2]), 'bad args');
+    waitsFor(assertArgs(this.spy, 1, ['event', 1, 2]), 'bad args');
+  });
+
+  it('callback execution should be cancellable', function() {
+    var cancelSpy = jasmine.createSpy().andCallFake(cancel);
+
+    this.target
+    .onSync('one', cancelSpy)
+    .onSync('one', this.spy)
+    .onAsync('two', cancelSpy)
+    .onAsync('two', this.spy)
+    .onSync('three', cancelSpy)
+    .onAsync('three', this.spy)
+    .trigger('one two three');
+
+    waitsFor(assertCallCount(cancelSpy, 3));
+    waitsFor(assertCallCount(this.spy, 0));
+
+    function cancel() { return false; }
+  });
+
+  function assertCallCount(spy, expected) {
+    return function() { return spy.callCount === expected; };
+  }
+
+  function assertArgs(spy, call, expected) {
+    return function() {
+      var env = jasmine.getEnv(),
+          actual = spy.calls[call] ? spy.calls[call].args : undefined;
+
+      return env.equals_(actual, expected);
+    };
+  }
+
+});

data/vendor/assets/bower_components/typeahead.js/test/fixtures/ajax_responses.js

@@ -0,0 +1,19 @@
+var fixtures = fixtures || {};
+
+fixtures.ajaxResps = {
+  ok: {
+    status: 200,
+    responseText: '[{ "value": "big" }, { "value": "bigger" }, { "value": "biggest" }, { "value": "small" }, { "value": "smaller" }, { "value": "smallest" }]'
+  },
+  ok1: {
+    status: 200,
+    responseText: '["dog", "cat", "moose"]'
+  },
+  err: {
+    status: 500
+  }
+};
+
+$.each(fixtures.ajaxResps, function(i, resp) {
+  resp.responseText && (resp.parsed = $.parseJSON(resp.responseText));
+});

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

@@ -0,0 +1,116 @@
+var fixtures = fixtures || {};
+
+fixtures.data = {
+  simple: [
+    { value: 'big' },
+    { value: 'bigger' },
+    { value: 'biggest' },
+    { value: 'small' },
+    { value: 'smaller' },
+    { value: 'smallest' }
+  ],
+  animals: [
+    { value: 'dog' },
+    { value: 'cat' },
+    { value: 'moose' }
+  ]
+};
+
+fixtures.serialized = {
+  simple: {
+    "datums": [
+      { "value": "big" },
+      { "value": "bigger" },
+      { "value": "biggest" },
+      { "value": "small" },
+      { "value": "smaller" },
+      { "value": "smallest" }
+    ],
+    "trie": {
+      "ids": [],
+      "children": {
+        "b": {
+          "ids": [0, 1, 2],
+          "children": {
+            "i": {
+              "ids": [0, 1, 2],
+              "children": {
+                "g": {
+                  "ids": [0, 1, 2],
+                  "children": {
+                    "g": {
+                      "ids": [1, 2],
+                      "children": {
+                        "e": {
+                          "ids": [1, 2],
+                          "children": {
+                            "r": {
+                              "ids": [1],
+                              "children": {}
+                            },
+                            "s": {
+                              "ids": [2],
+                              "children": {
+                                "t": {
+                                  "ids": [2],
+                                  "children": {}
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "s": {
+          "ids": [3, 4, 5],
+          "children": {
+            "m": {
+              "ids": [3, 4, 5],
+              "children": {
+                "a": {
+                  "ids": [3, 4, 5],
+                  "children": {
+                    "l": {
+                      "ids": [3, 4, 5],
+                      "children": {
+                        "l": {
+                          "ids": [3, 4, 5],
+                          "children": {
+                            "e": {
+                              "ids": [4, 5],
+                              "children": {
+                                "r": {
+                                  "ids": [4],
+                                  "children": {}
+                                },
+                                "s": {
+                                  "ids": [5],
+                                  "children": {
+                                    "t": {
+                                      "ids": [5],
+                                      "children": {}
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

data/vendor/assets/bower_components/typeahead.js/test/fixtures/html.js

@@ -0,0 +1,17 @@
+var fixtures = fixtures || {};
+
+fixtures.html = {
+  textInput: '<input type="text">',
+  input: '<input class="tt-input" type="text" autocomplete="false" spellcheck="false">',
+  hint: '<input class="tt-hint" type="text" autocomplete="false" spellcheck="false" disabled>',
+  menu: '<span class="tt-dropdown-menu"></span>',
+  dataset: [
+    '<div class="tt-dataset-test">',
+      '<span class="tt-suggestions">',
+        '<div class="tt-suggestion"><p>one</p></div>',
+        '<div class="tt-suggestion"><p>two</p></div>',
+        '<div class="tt-suggestion"><p>three</p></div>',
+      '</span>',
+    '</div>'
+  ].join('')
+};

data/vendor/assets/bower_components/typeahead.js/test/helpers/typeahead_mocks.js

@@ -0,0 +1,71 @@
+(function(root) {
+  var components;
+
+  components = [
+    'Bloodhound',
+    'PersistentStorage',
+    'Transport',
+    'SearchIndex',
+    'Input',
+    'Dataset',
+    'Dropdown'
+    ];
+
+  for (var i = 0; i < components.length; i++) {
+    makeMockable(components[i]);
+  }
+
+  function makeMockable(component) {
+    var Original, Mock;
+
+    Original = root[component];
+    Mock = mock(Original);
+
+    jasmine[component] = { useMock: useMock, uninstallMock: uninstallMock };
+
+    function useMock() {
+      root[component] = Mock;
+      jasmine.getEnv().currentSpec.after(uninstallMock);
+    }
+
+    function uninstallMock() {
+      root[component] = Original;
+    }
+  }
+
+  function mock(Constructor) {
+    var constructorSpy;
+
+    Mock.prototype = Constructor.prototype;
+    constructorSpy = jasmine.createSpy('mock constructor').andCallFake(Mock);
+
+    // copy instance methods
+    for (var key in Constructor) {
+      if (typeof Constructor[key] === 'function') {
+        constructorSpy[key] = Constructor[key];
+      }
+    }
+
+    return constructorSpy;
+
+    function Mock() {
+      var instance = _.mixin({}, Constructor.prototype);
+
+      for (var key in instance) {
+        if (typeof instance[key] === 'function') {
+          spyOn(instance, key);
+        }
+      }
+
+      // have the event emitter methods call through
+      instance.onSync && instance.onSync.andCallThrough();
+      instance.onAsync && instance.onAsync.andCallThrough();
+      instance.off && instance.off.andCallThrough();
+      instance.trigger && instance.trigger.andCallThrough();
+
+      instance.constructor = Constructor;
+
+      return instance;
+    }
+  }
+})(this);

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

@@ -0,0 +1,117 @@
+describe('highlight', function() {
+  it('should allow tagName to be specified', function() {
+    var before = 'abcde',
+        after = 'a<span>bcd</span>e',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'bcd', tagName: 'span' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should allow className to be specified', function() {
+    var before = 'abcde',
+        after = 'a<strong class="one two">bcd</strong>e',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'bcd', className: 'one two' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should be case insensitive by default', function() {
+    var before = 'ABCDE',
+        after = 'A<strong>BCD</strong>E',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'bcd' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should support case sensitivity', function() {
+    var before = 'ABCDE',
+        after = 'ABCDE',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'bcd', caseSensitive: true });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should support words only matching', function() {
+    var before = 'tone one phone',
+        after = 'tone <strong>one</strong> phone',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'one', wordsOnly: true });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should support matching multiple patterns', function() {
+    var before = 'tone one phone',
+        after = '<strong>tone</strong> one <strong>phone</strong>',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: ['tone', 'phone'] });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should support regex chars in the pattern', function() {
+    var before = '*.js when?',
+        after = '<strong>*.</strong>js when<strong>?</strong>',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: ['*.', '?'] });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should work on complex html structures', function() {
+    var before = [
+          '<div>abcde',
+            '<span>abcde</span>',
+            '<div><p>abcde</p></div>',
+          '</div>'
+        ].join(''),
+        after = [
+          '<div><strong>abc</strong>de',
+            '<span><strong>abc</strong>de</span>',
+            '<div><p><strong>abc</strong>de</p></div>',
+          '</div>'
+        ].join(''),
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'abc' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should ignore html tags and attributes', function() {
+    var before = '<span class="class"></span>',
+        after = '<span class="class"></span>',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: ['span', 'class'] });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should not match across tags', function() {
+    var before = 'a<span>b</span>c',
+        after = 'a<span>b</span>c',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'abc' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  it('should ignore html comments', function() {
+    var before = '<!-- abc -->',
+        after = '<!-- abc -->',
+        testNode = buildTestNode(before);
+
+    highlight({ node: testNode, pattern: 'abc' });
+    expect(testNode.innerHTML).toEqual(after);
+  });
+
+  function buildTestNode(content) {
+    var node = document.createElement('div');
+    node.innerHTML = content;
+
+    return node;
+  }
+});