discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,123 +0,0 @@
-import EmberObject from '../../lib/system/object';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class FilterTest extends AbstractTestCase {
-  '@test filter should invoke on each item'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let cnt = ary.length - 2;
-    let found = [];
-    let result;
-
-    // return true on all but the last two
-    result = obj.filter(function(i) {
-      found.push(i);
-      return --cnt >= 0;
-    });
-    this.assert.deepEqual(found, ary, 'should have invoked on each item');
-    this.assert.deepEqual(result, ary.slice(0, -2), 'filtered array should exclude items');
-  }
-}
-
-class FilterByTest extends AbstractTestCase {
-  '@test should filter 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.filterBy('foo', 'foo'), ary, 'filterBy(foo)');
-    this.assert.deepEqual(obj.filterBy('bar', 'bar'), [ary[1]], 'filterBy(bar)');
-  }
-
-  '@test should include in result if property is true'() {
-    let obj, ary;
-
-    ary = [{ foo: 'foo', bar: true }, EmberObject.create({ foo: 'bar', bar: false })];
-
-    obj = this.newObject(ary);
-
-    // different values - all eval to true
-    this.assert.deepEqual(obj.filterBy('foo'), ary, 'filterBy(foo)');
-    this.assert.deepEqual(obj.filterBy('bar'), [ary[0]], 'filterBy(bar)');
-  }
-
-  '@test should filter 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.filterBy('foo', 3), [ary[0], ary[3]], "filterBy('foo', 3)')");
-  }
-
-  '@test should correctly filter 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.filterBy('foo', null), [ary[1], ary[2]], "filterBy('foo', 3)')");
-  }
-
-  '@test should not return all objects on 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.filterBy('foo', undefined), [], "filterBy('foo', 3)')");
-  }
-
-  '@test should correctly filter 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.filterBy('foo', undefined), ary.slice(2), "filterBy('foo', 3)')");
-  }
-
-  '@test should not match undefined 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' }),
-    ];
-
-    obj = this.newObject(ary);
-
-    this.assert.deepEqual(obj.filterBy('foo'), ary.slice(0, 2), "filterBy('foo', 3)')");
-  }
-}
-
-runArrayTests('filter', FilterTest);
-runArrayTests('filter', FilterByTest);

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

@@ -1,86 +0,0 @@
-import EmberObject from '../../lib/system/object';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class FindTests extends AbstractTestCase {
-  '@test find should invoke callback on each item as long as you return false'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let found = [];
-    let result;
-
-    result = obj.find(function(i) {
-      found.push(i);
-      return false;
-    });
-    this.assert.equal(result, undefined, 'return value of obj.find');
-    this.assert.deepEqual(found, ary, 'items passed during find() should match');
-  }
-
-  '@test every should stop invoking when you return true'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let cnt = ary.length - 2;
-    let exp = cnt;
-    let found = [];
-    let result;
-
-    result = obj.find(function(i) {
-      found.push(i);
-      return --cnt >= 0;
-    });
-    this.assert.equal(result, ary[exp - 1], 'return value of obj.find');
-    this.assert.equal(found.length, exp, 'should invoke proper number of times');
-    this.assert.deepEqual(found, ary.slice(0, -2), 'items passed during find() should match');
-  }
-}
-
-class FindByTests extends AbstractTestCase {
-  '@test should return first object of property matches'() {
-    let ary, obj;
-
-    ary = [{ foo: 'foo', bar: 'BAZ' }, EmberObject.create({ foo: 'foo', bar: 'bar' })];
-
-    obj = this.newObject(ary);
-
-    this.assert.equal(obj.findBy('foo', 'foo'), ary[0], 'findBy(foo)');
-    this.assert.equal(obj.findBy('bar', 'bar'), ary[1], 'findBy(bar)');
-  }
-
-  '@test should return first object with truthy prop'() {
-    let ary, obj;
-
-    ary = [{ foo: 'foo', bar: false }, EmberObject.create({ foo: 'bar', bar: true })];
-
-    obj = this.newObject(ary);
-
-    // different values - all eval to true
-    this.assert.equal(obj.findBy('foo'), ary[0], 'findBy(foo)');
-    this.assert.equal(obj.findBy('bar'), ary[1], 'findBy(bar)');
-  }
-
-  '@test should return first null property match'() {
-    let ary, obj;
-
-    ary = [{ foo: null, bar: 'BAZ' }, EmberObject.create({ foo: null, bar: null })];
-
-    obj = this.newObject(ary);
-
-    this.assert.equal(obj.findBy('foo', null), ary[0], "findBy('foo', null)");
-    this.assert.equal(obj.findBy('bar', null), ary[1], "findBy('bar', null)");
-  }
-
-  '@test should return first undefined property match'() {
-    let ary, obj;
-
-    ary = [{ foo: undefined, bar: 'BAZ' }, EmberObject.create({})];
-
-    obj = this.newObject(ary);
-
-    this.assert.equal(obj.findBy('foo', undefined), ary[0], "findBy('foo', undefined)");
-    this.assert.equal(obj.findBy('bar', undefined), ary[1], "findBy('bar', undefined)");
-  }
-}
-
-runArrayTests('find', FindTests);
-runArrayTests('findBy', FindByTests);

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

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

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

@@ -1,68 +0,0 @@
-import { guidFor } from 'ember-utils';
-import { get } from 'ember-metal';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class ForEachTests extends AbstractTestCase {
-  '@test forEach should iterate over list'() {
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let found = [];
-
-    obj.forEach(i => found.push(i));
-    this.assert.deepEqual(found, ary, 'items passed during forEach should match');
-  }
-
-  '@test forEach should iterate over list after mutation'() {
-    if (get(this, 'canTestMutation')) {
-      this.assert.expect(0);
-      return;
-    }
-
-    let obj = this.newObject();
-    let ary = this.toArray(obj);
-    let found = [];
-
-    obj.forEach(i => found.push(i));
-    this.assert.deepEqual(found, ary, 'items passed during forEach should match');
-
-    this.mutate(obj);
-    ary = this.toArray(obj);
-    found = [];
-
-    obj.forEach(i => found.push(i));
-    this.assert.deepEqual(found, ary, 'items passed during forEach should match');
-  }
-
-  '@test 2nd target parameter'() {
-    let obj = this.newObject();
-    let target = this;
-
-    obj.forEach(() => {
-      // 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.forEach(() => {
-      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.forEach((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('forEach', ForEachTests);

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

@@ -1,46 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class IncludesTests extends AbstractTestCase {
-  '@test includes returns correct value if startAt is positive'() {
-    let data = newFixture(3);
-    let obj = this.newObject(data);
-
-    this.assert.equal(obj.includes(data[1], 1), true, 'should return true if included');
-    this.assert.equal(obj.includes(data[0], 1), false, 'should return false if not included');
-  }
-
-  '@test includes returns correct value if startAt is negative'() {
-    let data = newFixture(3);
-    let obj = this.newObject(data);
-
-    this.assert.equal(obj.includes(data[1], -2), true, 'should return true if included');
-    this.assert.equal(obj.includes(data[0], -2), false, 'should return false if not included');
-  }
-
-  '@test includes returns true if startAt + length is still negative'() {
-    let data = newFixture(1);
-    let obj = this.newObject(data);
-
-    this.assert.equal(obj.includes(data[0], -2), true, 'should return true if included');
-    this.assert.equal(
-      obj.includes(newFixture(1), -2),
-      false,
-      'should return false if not included'
-    );
-  }
-
-  '@test includes returns false if startAt out of bounds'() {
-    let data = newFixture(1);
-    let obj = this.newObject(data);
-
-    this.assert.equal(obj.includes(data[0], 2), false, 'should return false if startAt >= length');
-    this.assert.equal(
-      obj.includes(newFixture(1), 2),
-      false,
-      'should return false if startAt >= length'
-    );
-  }
-}
-
-runArrayTests('includes', IncludesTests);

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

@@ -1,27 +0,0 @@
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests, newFixture } from '../helpers/array';
-
-class IndexOfTests extends AbstractTestCase {
-  '@test should return index of object'() {
-    let expected = newFixture(3);
-    let obj = this.newObject(expected);
-    let len = 3;
-
-    for (let idx = 0; idx < len; idx++) {
-      this.assert.equal(
-        obj.indexOf(expected[idx]),
-        idx,
-        `obj.indexOf(${expected[idx]}) should match idx`
-      );
-    }
-  }
-
-  '@test should return -1 when requesting object not in index'() {
-    let obj = this.newObject(newFixture(3));
-    let foo = {};
-
-    this.assert.equal(obj.indexOf(foo), -1, 'obj.indexOf(foo) should be < 0');
-  }
-}
-
-runArrayTests('indexOf', IndexOfTests);

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

@@ -1,60 +0,0 @@
-import { Object as EmberObject, NativeArray } from '../../index';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class InvokeTests extends AbstractTestCase {
-  '@test invoke should call on each object that implements'() {
-    let cnt, ary, obj;
-
-    function F(amt) {
-      cnt += amt === undefined ? 1 : amt;
-    }
-    cnt = 0;
-    ary = [
-      { foo: F },
-      EmberObject.create({ foo: F }),
-
-      // NOTE: does not impl foo - invoke should just skip
-      EmberObject.create({ bar: F }),
-
-      { foo: F },
-    ];
-
-    obj = this.newObject(ary);
-    obj.invoke('foo');
-    this.assert.equal(cnt, 3, 'should have invoked 3 times');
-
-    cnt = 0;
-    obj.invoke('foo', 2);
-    this.assert.equal(cnt, 6, 'should have invoked 3 times, passing param');
-  }
-
-  '@test invoke should return an array containing the results of each invoked method'(assert) {
-    let obj = this.newObject([
-      {
-        foo() {
-          return 'one';
-        },
-      },
-      {}, // intentionally not including `foo` method
-      {
-        foo() {
-          return 'two';
-        },
-      },
-    ]);
-
-    let result = obj.invoke('foo');
-    assert.deepEqual(result, ['one', undefined, 'two']);
-  }
-
-  '@test invoke should return an extended array (aka Ember.A)'(assert) {
-    let obj = this.newObject([{ foo() {} }, { foo() {} }]);
-
-    let result = obj.invoke('foo');
-
-    assert.ok(NativeArray.detect(result), 'NativeArray has been applied');
-  }
-}
-
-runArrayTests('invoke', InvokeTests);

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

@@ -1,53 +0,0 @@
-import EmberObject from '../../lib/system/object';
-import { AbstractTestCase } from 'internal-test-helpers';
-import { runArrayTests } from '../helpers/array';
-
-class IsAnyTests extends AbstractTestCase {
-  '@test should return true of any property matches'() {
-    let obj = this.newObject([
-      { foo: 'foo', bar: 'BAZ' },
-      EmberObject.create({ foo: 'foo', bar: 'bar' }),
-    ]);
-
-    this.assert.equal(obj.isAny('foo', 'foo'), true, 'isAny(foo)');
-    this.assert.equal(obj.isAny('bar', 'bar'), true, 'isAny(bar)');
-    this.assert.equal(obj.isAny('bar', 'BIFF'), false, 'isAny(BIFF)');
-  }
-
-  '@test should return true of any property is true'() {
-    let obj = this.newObject([
-      { foo: 'foo', bar: true },
-      EmberObject.create({ foo: 'bar', bar: false }),
-    ]);
-
-    // different values - all eval to true
-    this.assert.equal(obj.isAny('foo'), true, 'isAny(foo)');
-    this.assert.equal(obj.isAny('bar'), true, 'isAny(bar)');
-    this.assert.equal(obj.isAny('BIFF'), false, 'isAny(biff)');
-  }
-
-  '@test should return true if any property matches null'() {
-    let obj = this.newObject([
-      { foo: null, bar: 'bar' },
-      EmberObject.create({ foo: 'foo', bar: null }),
-    ]);
-
-    this.assert.equal(obj.isAny('foo', null), true, "isAny('foo', null)");
-    this.assert.equal(obj.isAny('bar', null), true, "isAny('bar', null)");
-  }
-
-  '@test should return true if any property is undefined'() {
-    let obj = this.newObject([{ foo: undefined, bar: 'bar' }, EmberObject.create({ foo: 'foo' })]);
-
-    this.assert.equal(obj.isAny('foo', undefined), true, "isAny('foo', undefined)");
-    this.assert.equal(obj.isAny('bar', undefined), true, "isAny('bar', undefined)");
-  }
-
-  '@test should not match undefined properties without second argument'() {
-    let obj = this.newObject([{ foo: undefined }, EmberObject.create({})]);
-
-    this.assert.equal(obj.isAny('foo'), false, "isAny('foo', undefined)");
-  }
-}
-
-runArrayTests('isAny', IsAnyTests);