discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/tests/array/uniqBy-test.js

@@ -1,33 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class UniqByTests extends AbstractTestCase {
-  '@test should return new instance with duplicates removed'() {
-    let numbers = this.newObject([
-      { id: 1, value: 'one' },
-      { id: 2, value: 'two' },
-      { id: 1, value: 'one' },
-    ]);
-    this.assert.deepEqual(numbers.uniqBy('id'), [{ id: 1, value: 'one' }, { id: 2, value: 'two' }]);
-  }
-
-  '@test supports function as key'() {
-    let numbers = this.newObject([
-      { id: 1, value: 'boom' },
-      { id: 2, value: 'boom' },
-      { id: 1, value: 'doom' },
-    ]);
-
-    let keyFunction = val => {
-      this.assert.equal(arguments.length, 1);
-      return val.value;
-    };
-
-    this.assert.deepEqual(numbers.uniqBy(keyFunction), [
-      { id: 1, value: 'boom' },
-      { id: 1, value: 'doom' },
-    ]);
-  }
-}
-
-runArrayTests('uniqBy', UniqByTests);

data/dist/es/ember-runtime/tests/array/without-test.js

@@ -1,39 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class WithoutTests extends AbstractTestCase {
-  '@test should return new instance with item removed'() {
-    let before, after, obj, ret;
-
-    before = newFixture(3);
-    after = [before[0], before[2]];
-    obj = this.newObject(before);
-
-    ret = obj.without(before[1]);
-    this.assert.deepEqual(this.toArray(ret), after, 'should have removed item');
-    this.assert.deepEqual(this.toArray(obj), before, 'should not have changed original');
-  }
-
-  '@test should remove NaN value'() {
-    let before, after, obj, ret;
-
-    before = [...newFixture(2), NaN];
-    after = [before[0], before[1]];
-    obj = this.newObject(before);
-
-    ret = obj.without(NaN);
-    this.assert.deepEqual(this.toArray(ret), after, 'should have removed item');
-  }
-
-  '@test should return same instance if object not found'() {
-    let item, obj, ret;
-
-    item = newFixture(1)[0];
-    obj = this.newObject(newFixture(3));
-
-    ret = obj.without(item);
-    this.assert.equal(ret, obj, 'should be same instance');
-  }
-}
-
-runArrayTests('without', WithoutTests);

data/dist/es/ember-runtime/tests/copyable-array/copy-test.js

@@ -1,12 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class CopyTest extends AbstractTestCase {
-  '@test should return an equivalent copy'() {
-    let obj = this.newObject();
-    let copy = obj.copy();
-    this.assert.ok(this.isEqual(obj, copy), 'old object and new object should be equivalent');
-  }
-}
-
-runArrayTests('copy', CopyTest, 'CopyableNativeArray', 'CopyableArray');

data/dist/es/ember-runtime/tests/core/compare_test.js

@@ -1,89 +0,0 @@
-import { typeOf } from '../../lib/type-of';
-import EmberObject from '../../lib/system/object';
-import compare from '../../lib/compare';
-import Comparable from '../../lib/mixins/comparable';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let data = [];
-let Comp = EmberObject.extend(Comparable);
-
-Comp.reopenClass({
-  compare(obj) {
-    return obj.get('val');
-  },
-});
-
-moduleFor(
-  'Ember.compare()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      data[0] = null;
-      data[1] = false;
-      data[2] = true;
-      data[3] = -12;
-      data[4] = 3.5;
-      data[5] = 'a string';
-      data[6] = 'another string';
-      data[7] = 'last string';
-      data[8] = [1, 2];
-      data[9] = [1, 2, 3];
-      data[10] = [1, 3];
-      data[11] = { a: 'hash' };
-      data[12] = EmberObject.create();
-      data[13] = function(a) {
-        return a;
-      };
-      data[14] = new Date('2012/01/01');
-      data[15] = new Date('2012/06/06');
-    }
-
-    ['@test ordering should work'](assert) {
-      let suspect, comparable, failureMessage, suspectIndex, comparableIndex;
-
-      for (suspectIndex = 0; suspectIndex < data.length; suspectIndex++) {
-        suspect = data[suspectIndex];
-
-        assert.equal(compare(suspect, suspect), 0, suspectIndex + ' should equal itself');
-
-        for (comparableIndex = suspectIndex + 1; comparableIndex < data.length; comparableIndex++) {
-          comparable = data[comparableIndex];
-
-          failureMessage =
-            'data[' +
-            suspectIndex +
-            '] (' +
-            typeOf(suspect) +
-            ') should be smaller than data[' +
-            comparableIndex +
-            '] (' +
-            typeOf(comparable) +
-            ')';
-
-          assert.equal(compare(suspect, comparable), -1, failureMessage);
-        }
-      }
-    }
-
-    ['@test comparables should return values in the range of -1, 0, 1'](assert) {
-      let negOne = Comp.create({
-        val: -1,
-      });
-
-      let zero = Comp.create({
-        val: 0,
-      });
-
-      let one = Comp.create({
-        val: 1,
-      });
-
-      assert.equal(compare(negOne, 'a'), -1, 'First item comparable - returns -1 (not negated)');
-      assert.equal(compare(zero, 'b'), 0, 'First item comparable - returns  0 (not negated)');
-      assert.equal(compare(one, 'c'), 1, 'First item comparable - returns  1 (not negated)');
-
-      assert.equal(compare('a', negOne), 1, 'Second item comparable - returns -1 (negated)');
-      assert.equal(compare('b', zero), 0, 'Second item comparable - returns  0 (negated)');
-      assert.equal(compare('c', one), -1, 'Second item comparable - returns  1 (negated)');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/core/copy_test.js

@@ -1,47 +0,0 @@
-import copy from '../../lib/copy';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember Copy Method',
-  class extends AbstractTestCase {
-    ['@test Ember.copy null'](assert) {
-      let obj = { field: null };
-      let copied = null;
-      expectDeprecation(() => {
-        copied = copy(obj, true);
-      }, 'Use ember-copy addon instead of copy method and Copyable mixin.');
-      assert.equal(copied.field, null, 'null should still be null');
-    }
-
-    ['@test Ember.copy date'](assert) {
-      let date = new Date(2014, 7, 22);
-      let dateCopy = null;
-      expectDeprecation(() => {
-        dateCopy = copy(date);
-      }, 'Use ember-copy addon instead of copy method and Copyable mixin.');
-      assert.equal(date.getTime(), dateCopy.getTime(), 'dates should be equivalent');
-    }
-
-    ['@test Ember.copy null prototype object'](assert) {
-      let obj = Object.create(null);
-
-      obj.foo = 'bar';
-      let copied = null;
-      expectDeprecation(() => {
-        copied = copy(obj);
-      }, 'Use ember-copy addon instead of copy method and Copyable mixin.');
-
-      assert.equal(copied.foo, 'bar', 'bar should still be bar');
-    }
-
-    ['@test Ember.copy Array'](assert) {
-      let array = [1, null, new Date(2015, 9, 9), 'four'];
-      let arrayCopy = null;
-      expectDeprecation(() => {
-        arrayCopy = copy(array);
-      }, 'Use ember-copy addon instead of copy method and Copyable mixin.');
-
-      assert.deepEqual(array, arrayCopy, 'array content cloned successfully in new array');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/core/isEqual_test.js

@@ -1,65 +0,0 @@
-import isEqual from '../../lib/is-equal';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'isEqual',
-  class extends AbstractTestCase {
-    ['@test undefined and null'](assert) {
-      assert.ok(isEqual(undefined, undefined), 'undefined is equal to undefined');
-      assert.ok(!isEqual(undefined, null), 'undefined is not equal to null');
-      assert.ok(isEqual(null, null), 'null is equal to null');
-      assert.ok(!isEqual(null, undefined), 'null is not equal to undefined');
-    }
-
-    ['@test strings should be equal'](assert) {
-      assert.ok(!isEqual('Hello', 'Hi'), 'different Strings are unequal');
-      assert.ok(isEqual('Hello', 'Hello'), 'same Strings are equal');
-    }
-
-    ['@test numericals should be equal'](assert) {
-      assert.ok(isEqual(24, 24), 'same numbers are equal');
-      assert.ok(!isEqual(24, 21), 'different numbers are inequal');
-    }
-
-    ['@test dates should be equal'](assert) {
-      assert.ok(isEqual(new Date(1985, 7, 22), new Date(1985, 7, 22)), 'same dates are equal');
-      assert.ok(
-        !isEqual(new Date(2014, 7, 22), new Date(1985, 7, 22)),
-        'different dates are not equal'
-      );
-    }
-
-    ['@test array should be equal'](assert) {
-      // NOTE: We don't test for array contents -- that would be too expensive.
-      assert.ok(
-        !isEqual([1, 2], [1, 2]),
-        'two array instances with the same values should not be equal'
-      );
-      assert.ok(
-        !isEqual([1, 2], [1]),
-        'two array instances with different values should not be equal'
-      );
-    }
-
-    ['@test first object implements isEqual should use it'](assert) {
-      assert.ok(
-        isEqual(
-          {
-            isEqual() {
-              return true;
-            },
-          },
-          null
-        ),
-        'should return true always'
-      );
-
-      let obj = {
-        isEqual() {
-          return false;
-        },
-      };
-      assert.equal(isEqual(obj, obj), false, 'should return false because isEqual returns false');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/core/is_array_test.js

@@ -1,59 +0,0 @@
-import { A as emberA, isArray } from '../../lib/mixins/array';
-import ArrayProxy from '../../lib/system/array_proxy';
-import EmberObject from '../../lib/system/object';
-import { window } from 'ember-browser-environment';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-const global = this;
-
-moduleFor(
-  'Ember Type Checking',
-  class extends AbstractTestCase {
-    ['@test Ember.isArray'](assert) {
-      let numarray = [1, 2, 3];
-      let number = 23;
-      let strarray = ['Hello', 'Hi'];
-      let string = 'Hello';
-      let object = {};
-      let length = { length: 12 };
-      let strangeLength = { length: 'yes' };
-      let fn = function() {};
-      let arrayProxy = ArrayProxy.create({ content: emberA() });
-
-      assert.equal(isArray(numarray), true, '[1,2,3]');
-      assert.equal(isArray(number), false, '23');
-      assert.equal(isArray(strarray), true, '["Hello", "Hi"]');
-      assert.equal(isArray(string), false, '"Hello"');
-      assert.equal(isArray(object), false, '{}');
-      assert.equal(isArray(length), true, '{ length: 12 }');
-      assert.equal(isArray(strangeLength), false, '{ length: "yes" }');
-      assert.equal(isArray(global), false, 'global');
-      assert.equal(isArray(fn), false, 'function() {}');
-      assert.equal(isArray(arrayProxy), true, '[]');
-    }
-
-    '@test Ember.isArray does not trigger proxy assertion when probing for length GH#16495'(
-      assert
-    ) {
-      let instance = EmberObject.extend({
-        // intentionally returning non-null / non-undefined
-        unknownProperty() {
-          return false;
-        },
-      }).create();
-
-      assert.equal(isArray(instance), false);
-    }
-
-    ['@test Ember.isArray(fileList)'](assert) {
-      if (window && typeof window.FileList === 'function') {
-        let fileListElement = document.createElement('input');
-        fileListElement.type = 'file';
-        let fileList = fileListElement.files;
-        assert.equal(isArray(fileList), false, 'fileList');
-      } else {
-        assert.ok(true, 'FileList is not present on window');
-      }
-    }
-  }
-);

data/dist/es/ember-runtime/tests/core/is_empty_test.js

@@ -1,15 +0,0 @@
-import { isEmpty } from 'ember-metal';
-import ArrayProxy from '../../lib/system/array_proxy';
-import { A as emberA } from '../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.isEmpty',
-  class extends AbstractTestCase {
-    ['@test Ember.isEmpty'](assert) {
-      let arrayProxy = ArrayProxy.create({ content: emberA() });
-
-      assert.equal(true, isEmpty(arrayProxy), 'for an ArrayProxy that has empty content');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/core/type_of_test.js

@@ -1,54 +0,0 @@
-import { typeOf } from '../../lib/type-of';
-import EmberObject from '../../lib/system/object';
-import { window } from 'ember-browser-environment';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember Type Checking',
-  class extends AbstractTestCase {
-    ['@test Ember.typeOf'](assert) {
-      let MockedDate = function() {};
-      MockedDate.prototype = new Date();
-
-      let mockedDate = new MockedDate();
-      let date = new Date();
-      let error = new Error('boum');
-      let object = { a: 'b' };
-      let a = null;
-      let arr = [1, 2, 3];
-      let obj = {};
-      let instance = EmberObject.create({ method() {} });
-
-      assert.equal(typeOf(), 'undefined', 'undefined');
-      assert.equal(typeOf(null), 'null', 'null');
-      assert.equal(typeOf('Cyril'), 'string', 'Cyril');
-      assert.equal(typeOf(101), 'number', '101');
-      assert.equal(typeOf(true), 'boolean', 'true');
-      assert.equal(typeOf([1, 2, 90]), 'array', '[1,2,90]');
-      assert.equal(typeOf(/abc/), 'regexp', '/abc/');
-      assert.equal(typeOf(date), 'date', 'new Date()');
-      assert.equal(typeOf(mockedDate), 'date', 'mocked date');
-      assert.equal(typeOf(error), 'error', 'error');
-      assert.equal(typeOf(object), 'object', 'object');
-      assert.equal(typeOf(undefined), 'undefined', 'item of type undefined');
-      assert.equal(typeOf(a), 'null', 'item of type null');
-      assert.equal(typeOf(arr), 'array', 'item of type array');
-      assert.equal(typeOf(obj), 'object', 'item of type object');
-      assert.equal(typeOf(instance), 'instance', 'item of type instance');
-      assert.equal(typeOf(instance.method), 'function', 'item of type function');
-      assert.equal(typeOf(EmberObject.extend()), 'class', 'item of type class');
-      assert.equal(typeOf(new Error()), 'error', 'item of type error');
-    }
-
-    ['@test Ember.typeOf(fileList)'](assert) {
-      if (window && typeof window.FileList === 'function') {
-        let fileListElement = document.createElement('input');
-        fileListElement.type = 'file';
-        let fileList = fileListElement.files;
-        assert.equal(typeOf(fileList), 'filelist', 'item of type filelist');
-      } else {
-        assert.ok(true, 'FileList is not present on window');
-      }
-    }
-  }
-);

data/dist/es/ember-runtime/tests/ext/function_test.js

@@ -1,121 +0,0 @@
-import { ENV } from 'ember-environment';
-import { Mixin, mixin, get, set } from 'ember-metal';
-import EmberObject from '../../lib/system/object';
-import Evented from '../../lib/mixins/evented';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Function.prototype.observes() helper',
-  class extends AbstractTestCase {
-    ['@test global observer helper takes multiple params'](assert) {
-      if (!ENV.EXTEND_PROTOTYPES.Function) {
-        assert.ok(
-          'undefined' === typeof Function.prototype.observes,
-          'Function.prototype helper disabled'
-        );
-        return;
-      }
-
-      let MyMixin = Mixin.create({
-        count: 0,
-
-        foo: function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }.observes('bar', 'baz'),
-      });
-
-      let obj = mixin({}, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      set(obj, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 2, 'should invoke observer after change');
-    }
-  }
-);
-
-moduleFor(
-  'Function.prototype.on() helper',
-  class extends AbstractTestCase {
-    ['@test sets up an event listener, and can trigger the function on multiple events'](assert) {
-      if (!ENV.EXTEND_PROTOTYPES.Function) {
-        assert.ok(
-          'undefined' === typeof Function.prototype.on,
-          'Function.prototype helper disabled'
-        );
-        return;
-      }
-
-      let MyMixin = Mixin.create({
-        count: 0,
-
-        foo: function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }.on('bar', 'baz'),
-      });
-
-      let obj = mixin({}, Evented, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke listener immediately');
-
-      obj.trigger('bar');
-      obj.trigger('baz');
-      assert.equal(get(obj, 'count'), 2, 'should invoke listeners when events trigger');
-    }
-
-    ['@test can be chained with observes'](assert) {
-      if (!ENV.EXTEND_PROTOTYPES.Function) {
-        assert.ok('Function.prototype helper disabled');
-        return;
-      }
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        bay: 'bay',
-        foo: function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }
-          .observes('bay')
-          .on('bar'),
-      });
-
-      let obj = mixin({}, Evented, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke listener immediately');
-
-      set(obj, 'bay', 'BAY');
-      obj.trigger('bar');
-      assert.equal(get(obj, 'count'), 2, 'should invoke observer and listener');
-    }
-  }
-);
-
-moduleFor(
-  'Function.prototype.property() helper',
-  class extends AbstractTestCase {
-    ['@test sets up a ComputedProperty'](assert) {
-      if (!ENV.EXTEND_PROTOTYPES.Function) {
-        assert.ok(
-          'undefined' === typeof Function.prototype.property,
-          'Function.prototype helper disabled'
-        );
-        return;
-      }
-
-      let MyClass = EmberObject.extend({
-        firstName: null,
-        lastName: null,
-        fullName: function() {
-          return get(this, 'firstName') + ' ' + get(this, 'lastName');
-        }.property('firstName', 'lastName'),
-      });
-
-      let obj = MyClass.create({ firstName: 'Fred', lastName: 'Flinstone' });
-      assert.equal(get(obj, 'fullName'), 'Fred Flinstone', 'should return the computed value');
-
-      set(obj, 'firstName', 'Wilma');
-      assert.equal(get(obj, 'fullName'), 'Wilma Flinstone', 'should return the new computed value');
-
-      set(obj, 'lastName', '');
-      assert.equal(get(obj, 'fullName'), 'Wilma ', 'should return the new computed value');
-    }
-  }
-);