Initial commit

public/assets/vendor/select2-4.1.0-rc.0/tests/utils/data-tests.js

@@ -0,0 +1,55 @@
+var $ = require('jquery');
+var Utils = require('select2/utils');
+
+module('Utils - GetUniqueElementId');
+
+test('Adds a prefix to the existing ID if one exists', function (assert) {
+    var $element = $('<select id="existing-id"></select>');
+
+    var id = Utils.GetUniqueElementId($element[0]);
+
+    assert.notEqual(id, 'existing-id');
+    assert.notEqual(id.indexOf('existing-id'), -1);
+});
+
+test('Generated random ID is not a number', function (assert) {
+    var $element = $('<select></select>');
+
+    var id = Utils.GetUniqueElementId($element[0]);
+
+    assert.ok(isNaN(id));
+});
+
+module('Utils - RemoveData');
+
+test('The data-select2-id attribute is removed', function (assert) {
+    var $element = $('<select data-select2-id="test"></select>');
+
+    Utils.RemoveData($element[0]);
+
+    assert.notEqual(
+        $element.attr('data-select2-id'),
+        'test',
+        'The internal attribute was not removed when the data was cleared'
+    );
+});
+
+test('The internal cache for the element is cleared', function (assert) {
+    var $element = $('<select data-select2-id="test"></select>');
+
+    Utils.__cache.test = {
+        'foo': 'bar'
+    };
+
+    Utils.RemoveData($element[0]);
+
+    assert.equal(Utils.__cache.test, null, 'The cache should now be empty');
+});
+
+test('Calling it on an element without data works', function (assert) {
+    assert.expect(0);
+
+    var $element = $('<select></select>');
+
+    Utils.RemoveData($element[0]);
+});

public/assets/vendor/select2-4.1.0-rc.0/tests/utils/decorator-tests.js

@@ -0,0 +1,189 @@
+module('Decorators');
+
+var Utils = require('select2/utils');
+
+test('overridden - method', function (assert) {
+  function BaseClass () {}
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass () {}
+
+  DecoratorClass.prototype.hello = function () {
+    return 'B';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.strictEqual(inst.hello(), 'B');
+});
+
+test('overridden - constructor', function (assert) {
+  function BaseClass () {
+    this.inherited = true;
+  }
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass (decorated) {
+    this.called = true;
+  }
+
+  DecoratorClass.prototype.other = function () {
+    return 'B';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.ok(inst.called);
+  assert.ok(!inst.inherited);
+});
+
+test('not overridden - method', function (assert) {
+  function BaseClass () {}
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass () {}
+
+  DecoratorClass.prototype.other = function () {
+    return 'B';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.strictEqual(inst.hello(), 'A');
+});
+
+test('not overridden - constructor', function (assert) {
+  function BaseClass () {
+    this.called = true;
+  }
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass () {}
+
+  DecoratorClass.prototype.other = function () {
+    return 'B';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.ok(inst.called);
+});
+
+test('inherited - method', function (assert) {
+  function BaseClass () {}
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass (decorated) {}
+
+  DecoratorClass.prototype.hello = function (decorated) {
+    return 'B' + decorated.call(this) + 'C';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.strictEqual(inst.hello(), 'BAC');
+});
+
+test('inherited - constructor', function (assert) {
+  function BaseClass () {
+    this.inherited = true;
+  }
+
+  BaseClass.prototype.hello = function () {
+    return 'A';
+  };
+
+  function DecoratorClass (decorated) {
+    this.called = true;
+
+    decorated.call(this);
+  }
+
+  DecoratorClass.prototype.other = function () {
+    return 'B';
+  };
+
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+
+  var inst = new DecoratedClass();
+
+  assert.ok(inst.called);
+  assert.ok(inst.inherited);
+});
+
+test('inherited - three levels', function (assert) {
+  function BaseClass (testArgument) {
+    this.baseCalled = true;
+    this.baseTestArgument = testArgument;
+  }
+
+  BaseClass.prototype.test = function (a) {
+    return a + 'c';
+  };
+
+  function MiddleClass (decorated, testArgument) {
+    this.middleCalled = true;
+    this.middleTestArgument = testArgument;
+
+    decorated.call(this, testArgument);
+  }
+
+  MiddleClass.prototype.test = function (decorated, a) {
+    return decorated.call(this, a + 'b');
+  };
+
+  function DecoratorClass (decorated, testArgument) {
+    this.decoratorCalled = true;
+    this.decoratorTestArgument = testArgument;
+
+    decorated.call(this, testArgument);
+  }
+
+  DecoratorClass.prototype.test = function (decorated, a) {
+    return decorated.call(this, a + 'a');
+  };
+
+  var DecoratedClass = Utils.Decorate(
+    Utils.Decorate(BaseClass, MiddleClass),
+    DecoratorClass
+  );
+
+  var inst = new DecoratedClass('test');
+
+  assert.ok(inst.baseCalled, 'The base class contructor was called');
+  assert.ok(inst.middleCalled, 'The middle class constructor was called');
+  assert.ok(inst.decoratorCalled, 'The decorator constructor was called');
+
+  assert.strictEqual(inst.baseTestArgument, 'test');
+  assert.strictEqual(inst.middleTestArgument, 'test');
+  assert.strictEqual(inst.decoratorTestArgument, 'test');
+
+  var out = inst.test('test');
+
+  assert.strictEqual(out, 'testabc');
+});

public/assets/vendor/select2-4.1.0-rc.0/tests/utils/escapeMarkup-tests.js

@@ -0,0 +1,36 @@
+module('Utils - escapeMarkup');
+
+var Utils = require('select2/utils');
+
+test('text passes through', function (assert) {
+  var text = 'testing this';
+  var escaped = Utils.escapeMarkup(text);
+
+  assert.equal(text, escaped);
+});
+
+test('html tags are escaped', function (assert) {
+  var text = '<script>alert("bad");</script>';
+  var escaped = Utils.escapeMarkup(text);
+
+  assert.notEqual(text, escaped);
+  assert.equal(escaped.indexOf('<script>'), -1);
+});
+
+test('quotes are killed as well', function (assert) {
+  var text = 'testin\' these "quotes"';
+  var escaped = Utils.escapeMarkup(text);
+
+  assert.notEqual(text, escaped);
+  assert.equal(escaped.indexOf('\''), -1);
+  assert.equal(escaped.indexOf('"'), -1);
+});
+
+test('DocumentFragment options pass through', function (assert) {
+  var frag = document.createDocumentFragment();
+  frag.innerHTML = '<strong>test</strong>';
+
+  var escaped = Utils.escapeMarkup(frag);
+
+  assert.equal(frag, escaped);
+});