discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,78 +0,0 @@
-import { get } from 'ember-metal';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class LastIndexOfTests extends AbstractTestCase {
-  "@test should return index of object's last occurrence"() {
-    let expected = newFixture(3);
-    let obj = this.newObject(expected);
-    let len = 3;
-
-    for (let idx = 0; idx < len; idx++) {
-      this.assert.equal(
-        obj.lastIndexOf(expected[idx]),
-        idx,
-        `obj.lastIndexOf(${expected[idx]}) should match idx`
-      );
-    }
-  }
-
-  "@test should return index of object's last occurrence even startAt search location is equal to length"() {
-    let expected = newFixture(3);
-    let obj = this.newObject(expected);
-    let len = 3;
-
-    for (let idx = 0; idx < len; idx++) {
-      this.assert.equal(
-        obj.lastIndexOf(expected[idx], len),
-        idx,
-        `obj.lastIndexOfs(${expected[idx]}) should match idx`
-      );
-    }
-  }
-
-  "@test should return index of object's last occurrence even startAt search location is greater than length"() {
-    let expected = newFixture(3);
-    let obj = this.newObject(expected);
-    let len = 3;
-
-    for (let idx = 0; idx < len; idx++) {
-      this.assert.equal(
-        obj.lastIndexOf(expected[idx], len + 1),
-        idx,
-        `obj.lastIndexOf(${expected[idx]}) should match idx`
-      );
-    }
-  }
-
-  '@test should return -1 when no match is found'() {
-    let obj = this.newObject(newFixture(3));
-    let foo = {};
-
-    this.assert.equal(obj.lastIndexOf(foo), -1, 'obj.lastIndexOf(foo) should be -1');
-  }
-
-  '@test should return -1 when no match is found even startAt search location is equal to length'() {
-    let obj = this.newObject(newFixture(3));
-    let foo = {};
-
-    this.assert.equal(
-      obj.lastIndexOf(foo, get(obj, 'length')),
-      -1,
-      'obj.lastIndexOf(foo) should be -1'
-    );
-  }
-
-  '@test should return -1 when no match is found even startAt search location is greater than length'() {
-    let obj = this.newObject(newFixture(3));
-    let foo = {};
-
-    this.assert.equal(
-      obj.lastIndexOf(foo, get(obj, 'length') + 1),
-      -1,
-      'obj.lastIndexOf(foo) should be -1'
-    );
-  }
-}
-
-runArrayTests('lastIndexOf', LastIndexOfTests);

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

@@ -1,31 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-import { get, set } from 'ember-metal';
-
-class LastObjectTests extends AbstractTestCase {
-  '@test returns last item in enumerable'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-
-    this.assert.equal(get(obj, 'lastObject'), ary[ary.length - 1]);
-  }
-
-  '@test returns undefined if enumerable is empty'() {
-    let obj = this.newObject([]);
-
-    this.assert.equal(get(obj, 'lastObject'), undefined);
-  }
-
-  '@test can not be set'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-
-    this.assert.equal(get(obj, 'lastObject'), ary[ary.length - 1]);
-
-    this.assert.throws(function() {
-      set(obj, 'lastObject', 'foo!');
-    }, /Cannot set read-only property "lastObject" on object/);
-  }
-}
-
-runArrayTests('lastObject', LastObjectTests);

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

@@ -1,68 +0,0 @@
-import { guidFor } from 'ember-utils';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-import { get } from 'ember-metal';
-
-const mapFunc = item => (item ? item.toString() : null);
-
-class MapTests extends AbstractTestCase {
-  '@test map should iterate over list'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj).map(mapFunc);
-    let found = [];
-
-    found = obj.map(mapFunc);
-    this.assert.deepEqual(found, ary, 'mapped arrays should match');
-  }
-
-  '@test map should iterate over list after mutation'() {
-    if (get(this, 'canTestMutation')) {
-      this.assert.expect(0);
-      return;
-    }
-
-    let obj = this.newObject();
-    let ary = this.toArray(obj).map(mapFunc);
-    let found;
-
-    found = obj.map(mapFunc);
-    this.assert.deepEqual(found, ary, 'items passed during forEach should match');
-
-    this.mutate(obj);
-    ary = this.toArray(obj).map(mapFunc);
-    found = obj.map(mapFunc);
-    this.assert.deepEqual(found, ary, 'items passed during forEach should match');
-  }
-
-  '@test 2nd target parameter'() {
-    let obj = this.newObject();
-    let target = this;
-
-    obj.map(() => {
-      // ES6TODO: When transpiled we will end up with "use strict" which disables automatically binding to the global context.
-      // Therefore, the following test can never pass in strict mode unless we modify the `map` function implementation to
-      // use `Ember.lookup` if target is not specified.
-      //
-      // equal(guidFor(this), guidFor(global), 'should pass the global object as this if no context');
-    });
-
-    obj.map(() => {
-      this.assert.equal(guidFor(this), guidFor(target), 'should pass target as this if context');
-    }, target);
-  }
-
-  '@test callback params'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let loc = 0;
-
-    obj.map((item, idx, enumerable) => {
-      this.assert.equal(item, ary[loc], 'item param');
-      this.assert.equal(idx, loc, 'idx param');
-      this.assert.equal(guidFor(enumerable), guidFor(obj), 'enumerable param');
-      loc++;
-    });
-  }
-}
-
-runArrayTests('map', MapTests);

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

@@ -1,16 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class MapByTests extends AbstractTestCase {
-  '@test get value of each property'() {
-    let obj = this.newObject([{ a: 1 }, { a: 2 }]);
-    this.assert.equal(obj.mapBy('a').join(''), '12');
-  }
-
-  '@test should work also through getEach alias'() {
-    let obj = this.newObject([{ a: 1 }, { a: 2 }]);
-    this.assert.equal(obj.getEach('a').join(''), '12');
-  }
-}
-
-runArrayTests('mapBy', MapByTests);

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

@@ -1,34 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class ObjectAtTests extends AbstractTestCase {
-  '@test should return object at specified index'() {
-    let expected = newFixture(3);
-    let obj = this.newObject(expected);
-    let len = expected.length;
-
-    for (let idx = 0; idx < len; idx++) {
-      this.assert.equal(obj.objectAt(idx), expected[idx], `obj.objectAt(${idx}) should match`);
-    }
-  }
-
-  '@test should return undefined when requesting objects beyond index'() {
-    let obj;
-
-    obj = this.newObject(newFixture(3));
-    this.assert.equal(
-      obj.objectAt(obj, 5),
-      undefined,
-      'should return undefined for obj.objectAt(5) when len = 3'
-    );
-
-    obj = this.newObject([]);
-    this.assert.equal(
-      obj.objectAt(obj, 0),
-      undefined,
-      'should return undefined for obj.objectAt(0) when len = 0'
-    );
-  }
-}
-
-runArrayTests('objectAt', ObjectAtTests);

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

@@ -1,24 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class ReduceTests extends AbstractTestCase {
-  '@test collects a summary value from an enumeration'() {
-    let obj = this.newObject([1, 2, 3]);
-    let res = obj.reduce((previousValue, item) => previousValue + item, 0);
-    this.assert.equal(res, 6);
-  }
-
-  '@test passes index of item to callback'() {
-    let obj = this.newObject([1, 2, 3]);
-    let res = obj.reduce((previousValue, item, index) => previousValue + index, 0);
-    this.assert.equal(res, 3);
-  }
-
-  '@test passes enumerable object to callback'() {
-    let obj = this.newObject([1, 2, 3]);
-    let res = obj.reduce((previousValue, item, index, enumerable) => enumerable, 0);
-    this.assert.equal(res, obj);
-  }
-}
-
-runArrayTests('reduce', ReduceTests);

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

@@ -1,134 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-import EmberObject from '../../lib/system/object';
-
-class RejectTest extends AbstractTestCase {
-  '@test should reject any item that does not meet the condition'() {
-    let obj = this.newObject([1, 2, 3, 4]);
-    let result;
-
-    result = obj.reject(i => i < 3);
-    this.assert.deepEqual(result, [3, 4], 'reject the correct items');
-  }
-
-  '@test should be the inverse of filter'() {
-    let obj = this.newObject([1, 2, 3, 4]);
-    let isEven = i => i % 2 === 0;
-    let filtered, rejected;
-
-    filtered = obj.filter(isEven);
-    rejected = obj.reject(isEven);
-
-    this.assert.deepEqual(filtered, [2, 4], 'filtered evens');
-    this.assert.deepEqual(rejected, [1, 3], 'rejected evens');
-  }
-}
-
-class RejectByTest extends AbstractTestCase {
-  '@test should reject based on object'() {
-    let obj, ary;
-
-    ary = [{ foo: 'foo', bar: 'BAZ' }, EmberObject.create({ foo: 'foo', bar: 'bar' })];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('foo', 'foo'), [], 'rejectBy(foo)');
-    this.assert.deepEqual(obj.rejectBy('bar', 'bar'), [ary[0]], 'rejectBy(bar)');
-  }
-
-  '@test should include in result if property is false'() {
-    let obj, ary;
-
-    ary = [{ foo: false, bar: true }, EmberObject.create({ foo: false, bar: false })];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('foo'), ary, 'rejectBy(foo)');
-    this.assert.deepEqual(obj.rejectBy('bar'), [ary[1]], 'rejectBy(bar)');
-  }
-
-  '@test should reject on second argument if provided'() {
-    let obj, ary;
-
-    ary = [
-      { name: 'obj1', foo: 3 },
-      EmberObject.create({ name: 'obj2', foo: 2 }),
-      { name: 'obj3', foo: 2 },
-      EmberObject.create({ name: 'obj4', foo: 3 }),
-    ];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('foo', 3), [ary[1], ary[2]], "rejectBy('foo', 3)')");
-  }
-
-  '@test should correctly reject null second argument'() {
-    let obj, ary;
-
-    ary = [
-      { name: 'obj1', foo: 3 },
-      EmberObject.create({ name: 'obj2', foo: null }),
-      { name: 'obj3', foo: null },
-      EmberObject.create({ name: 'obj4', foo: 3 }),
-    ];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('foo', null), [ary[0], ary[3]], "rejectBy('foo', null)')");
-  }
-
-  '@test should correctly reject undefined second argument'() {
-    let obj, ary;
-
-    ary = [{ name: 'obj1', foo: 3 }, EmberObject.create({ name: 'obj2', foo: 2 })];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('bar', undefined), [], "rejectBy('bar', undefined)')");
-  }
-
-  '@test should correctly reject explicit undefined second argument'() {
-    let obj, ary;
-
-    ary = [
-      { name: 'obj1', foo: 3 },
-      EmberObject.create({ name: 'obj2', foo: 3 }),
-      { name: 'obj3', foo: undefined },
-      EmberObject.create({ name: 'obj4', foo: undefined }),
-      { name: 'obj5' },
-      EmberObject.create({ name: 'obj6' }),
-    ];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(
-      obj.rejectBy('foo', undefined),
-      ary.slice(0, 2),
-      "rejectBy('foo', undefined)')"
-    );
-  }
-
-  '@test should match undefined, null, or false properties without second argument'() {
-    let obj, ary;
-
-    ary = [
-      { name: 'obj1', foo: 3 },
-      EmberObject.create({ name: 'obj2', foo: 3 }),
-      { name: 'obj3', foo: undefined },
-      EmberObject.create({ name: 'obj4', foo: undefined }),
-      { name: 'obj5' },
-      EmberObject.create({ name: 'obj6' }),
-      { name: 'obj7', foo: null },
-      EmberObject.create({ name: 'obj8', foo: null }),
-      { name: 'obj9', foo: false },
-      EmberObject.create({ name: 'obj10', foo: false }),
-    ];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.rejectBy('foo'), ary.slice(2), "rejectBy('foo')')");
-  }
-}
-
-runArrayTests('reject', RejectTest);
-runArrayTests('rejectBy', RejectByTest);

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

@@ -1,23 +0,0 @@
-import { get } from 'ember-metal';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class SortByTests extends AbstractTestCase {
-  '@test sort by value of property'() {
-    let obj = this.newObject([{ a: 2 }, { a: 1 }]);
-    let sorted = obj.sortBy('a');
-
-    this.assert.equal(get(sorted[0], 'a'), 1);
-    this.assert.equal(get(sorted[1], 'a'), 2);
-  }
-
-  '@test supports multiple propertyNames'() {
-    let obj = this.newObject([{ a: 1, b: 2 }, { a: 1, b: 1 }]);
-    let sorted = obj.sortBy('a', 'b');
-
-    this.assert.equal(get(sorted[0], 'b'), 1);
-    this.assert.equal(get(sorted[1], 'b'), 2);
-  }
-}
-
-runArrayTests('sortBy', SortByTests);

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

@@ -1,11 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class ToArrayTests extends AbstractTestCase {
-  '@test toArray should convert to an array'() {
-    let obj = this.newObject();
-    this.assert.deepEqual(obj.toArray(), this.toArray(obj));
-  }
-}
-
-runArrayTests('toArray', ToArrayTests);

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

@@ -1,27 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class UniqTests extends AbstractTestCase {
-  '@test should return new instance with duplicates removed'() {
-    let before, after, obj, ret;
-
-    after = newFixture(3);
-    before = [after[0], after[1], after[2], after[1], after[0]];
-    obj = this.newObject(before);
-    before = obj.toArray(); // in case of set before will be different...
-
-    ret = obj.uniq();
-    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 return duplicate of same content if no duplicates found'() {
-    let item, obj, ret;
-    obj = this.newObject(newFixture(3));
-    ret = obj.uniq(item);
-    this.assert.ok(ret !== obj, 'should not be same object');
-    this.assert.deepEqual(this.toArray(ret), this.toArray(obj), 'should be the same content');
-  }
-}
-
-runArrayTests('uniq', UniqTests);