discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/tests/expand_properties_test.js

@@ -1,119 +0,0 @@
-import { expandProperties } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let foundProperties = [];
-
-function addProperty(property) {
-  foundProperties.push(property);
-}
-
-moduleFor(
-  'Property Brace Expansion Test',
-  class extends AbstractTestCase {
-    beforeEach() {
-      foundProperties = [];
-    }
-
-    ['@test Properties without expansions are unaffected'](assert) {
-      assert.expect(1);
-
-      expandProperties('a', addProperty);
-      expandProperties('a.b', addProperty);
-      expandProperties('a.b.[]', addProperty);
-      expandProperties('a.b.@each.c', addProperty);
-
-      assert.deepEqual(['a', 'a.b', 'a.b.[]', 'a.b.@each.c'].sort(), foundProperties.sort());
-    }
-
-    ['@test A single expansion at the end expands properly'](assert) {
-      assert.expect(1);
-
-      expandProperties('a.b.{c,d}', addProperty);
-
-      assert.deepEqual(['a.b.c', 'a.b.d'].sort(), foundProperties.sort());
-    }
-
-    ['@test A property with only a brace expansion expands correctly'](assert) {
-      assert.expect(1);
-
-      expandProperties('{a,b,c}', addProperty);
-
-      let expected = ['a', 'b', 'c'];
-      assert.deepEqual(expected.sort(), foundProperties.sort());
-    }
-
-    ['@test Expansions with single properties only expand once'](assert) {
-      assert.expect(1);
-
-      expandProperties('a.b.{c}.d.{e}', addProperty);
-
-      assert.deepEqual(['a.b.c.d.e'], foundProperties);
-    }
-
-    ['@test A single brace expansion expands correctly'](assert) {
-      assert.expect(1);
-
-      expandProperties('a.{b,c,d}.e', addProperty);
-
-      let expected = ['a.b.e', 'a.c.e', 'a.d.e'];
-      assert.deepEqual(expected.sort(), foundProperties.sort());
-    }
-
-    ['@test Multiple brace expansions work correctly'](assert) {
-      assert.expect(1);
-
-      expandProperties('{a,b,c}.d.{e,f}.g', addProperty);
-
-      let expected = ['a.d.e.g', 'a.d.f.g', 'b.d.e.g', 'b.d.f.g', 'c.d.e.g', 'c.d.f.g'];
-      assert.deepEqual(expected.sort(), foundProperties.sort());
-    }
-
-    ['@test A property with only brace expansions expands correctly'](assert) {
-      assert.expect(1);
-
-      expandProperties('{a,b,c}.{d}.{e,f}', addProperty);
-
-      let expected = ['a.d.e', 'a.d.f', 'b.d.e', 'b.d.f', 'c.d.e', 'c.d.f'];
-      assert.deepEqual(expected.sort(), foundProperties.sort());
-    }
-
-    ['@test Nested brace expansions are not allowed']() {
-      let nestedBraceProperties = [
-        'a.{b.{c,d}}',
-        'a.{{b}.c}',
-        'a.{b,c}.{d.{e,f}.g',
-        'a.{b.{c}',
-        'a.{b,c}}',
-        'model.{bar,baz',
-      ];
-
-      nestedBraceProperties.forEach(invalidProperties => {
-        expectAssertion(() => expandProperties(invalidProperties, addProperty));
-      }, /Brace expanded properties have to be balanced and cannot be nested/);
-    }
-
-    ['@test A property with no braces does not expand'](assert) {
-      assert.expect(1);
-
-      expandProperties('a,b,c.d.e,f', addProperty);
-
-      assert.deepEqual(foundProperties, ['a,b,c.d.e,f']);
-    }
-
-    ['@test A pattern must be a string'](assert) {
-      assert.expect(1);
-
-      expectAssertion(() => {
-        expandProperties([1, 2], addProperty);
-      }, /A computed property key must be a string/);
-    }
-
-    ['@test A pattern must not contain a space'](assert) {
-      assert.expect(1);
-
-      expectAssertion(function() {
-        expandProperties('{a, b}', addProperty);
-      }, /Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"/);
-    }
-  }
-);

data/dist/es/ember-metal/tests/injected_property_test.js

@@ -1,76 +0,0 @@
-import { setOwner } from 'ember-owner';
-import { Descriptor, defineProperty, get, set, InjectedProperty } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'InjectedProperty',
-  class extends AbstractTestCase {
-    ['@test injected properties should be descriptors'](assert) {
-      assert.ok(new InjectedProperty() instanceof Descriptor);
-    }
-
-    ['@test injected properties should be overridable'](assert) {
-      let obj = {};
-      defineProperty(obj, 'foo', new InjectedProperty());
-
-      set(obj, 'foo', 'bar');
-
-      assert.equal(get(obj, 'foo'), 'bar', 'should return the overridden value');
-    }
-
-    ['@test getting on an object without an owner or container should fail assertion']() {
-      let obj = {};
-      defineProperty(obj, 'foo', new InjectedProperty('type', 'name'));
-
-      expectAssertion(function() {
-        get(obj, 'foo');
-      }, /Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container./);
-    }
-
-    ['@test getting on an object without an owner but with a container should not fail'](assert) {
-      let obj = {
-        container: {
-          lookup(key) {
-            assert.ok(true, 'should call container.lookup');
-            return key;
-          },
-        },
-      };
-
-      defineProperty(obj, 'foo', new InjectedProperty('type', 'name'));
-
-      assert.equal(get(obj, 'foo'), 'type:name', 'should return the value of container.lookup');
-    }
-
-    ['@test getting should return a lookup on the container'](assert) {
-      assert.expect(2);
-
-      let obj = {};
-
-      setOwner(obj, {
-        lookup(key) {
-          assert.ok(true, 'should call container.lookup');
-          return key;
-        },
-      });
-
-      defineProperty(obj, 'foo', new InjectedProperty('type', 'name'));
-
-      assert.equal(get(obj, 'foo'), 'type:name', 'should return the value of container.lookup');
-    }
-
-    ['@test omitting the lookup name should default to the property name'](assert) {
-      let obj = {};
-
-      setOwner(obj, {
-        lookup(key) {
-          return key;
-        },
-      });
-
-      defineProperty(obj, 'foo', new InjectedProperty('type'));
-
-      assert.equal(get(obj, 'foo'), 'type:foo', 'should lookup the type using the property name');
-    }
-  }
-);

data/dist/es/ember-metal/tests/is_blank_test.js

@@ -1,29 +0,0 @@
-import { isBlank } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'isBlank',
-  class extends AbstractTestCase {
-    ['@test isBlank'](assert) {
-      let string = 'string';
-      let fn = function() {};
-      let object = { length: 0 };
-
-      assert.equal(true, isBlank(null), 'for null');
-      assert.equal(true, isBlank(undefined), 'for undefined');
-      assert.equal(true, isBlank(''), 'for an empty String');
-      assert.equal(true, isBlank('  '), 'for a whitespace String');
-      assert.equal(true, isBlank('\n\t'), 'for another whitespace String');
-      assert.equal(false, isBlank('\n\t Hi'), 'for a String with whitespaces');
-      assert.equal(false, isBlank(true), 'for true');
-      assert.equal(false, isBlank(false), 'for false');
-      assert.equal(false, isBlank(string), 'for a String');
-      assert.equal(false, isBlank(fn), 'for a Function');
-      assert.equal(false, isBlank(0), 'for 0');
-      assert.equal(true, isBlank([]), 'for an empty Array');
-      assert.equal(false, isBlank({}), 'for an empty Object');
-      assert.equal(true, isBlank(object), "for an Object that has zero 'length'");
-      assert.equal(false, isBlank([1, 2, 3]), 'for a non-empty array');
-    }
-  }
-);

data/dist/es/ember-metal/tests/is_empty_test.js

@@ -1,55 +0,0 @@
-import { isEmpty } from '..';
-import Map from '@ember/map';
-import OrderedSet from '@ember/map/lib/ordered-set';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'isEmpty',
-  class extends AbstractTestCase {
-    ['@test isEmpty'](assert) {
-      let string = 'string';
-      let fn = function() {};
-      let object = { length: 0 };
-
-      assert.equal(true, isEmpty(null), 'for null');
-      assert.equal(true, isEmpty(undefined), 'for undefined');
-      assert.equal(true, isEmpty(''), 'for an empty String');
-      assert.equal(false, isEmpty('  '), 'for a whitespace String');
-      assert.equal(false, isEmpty('\n\t'), 'for another whitespace String');
-      assert.equal(false, isEmpty(true), 'for true');
-      assert.equal(false, isEmpty(false), 'for false');
-      assert.equal(false, isEmpty(string), 'for a String');
-      assert.equal(false, isEmpty(fn), 'for a Function');
-      assert.equal(false, isEmpty(0), 'for 0');
-      assert.equal(true, isEmpty([]), 'for an empty Array');
-      assert.equal(false, isEmpty({}), 'for an empty Object');
-      assert.equal(true, isEmpty(object), "for an Object that has zero 'length'");
-    }
-
-    ['@test isEmpty Map'](assert) {
-      expectDeprecation(
-        () => {
-          let map = new Map();
-          assert.equal(true, isEmpty(map), 'Empty map is empty');
-          map.set('foo', 'bar');
-          assert.equal(false, isEmpty(map), 'Map is not empty');
-        },
-        'Use of @ember/Map is deprecated. Please use native `Map` instead',
-        { id: 'ember-map-deprecation', until: '3.5.0' }
-      );
-    }
-
-    ['@test isEmpty Ember.OrderedSet'](assert) {
-      expectDeprecation(
-        () => {
-          let orderedSet = new OrderedSet();
-          assert.equal(true, isEmpty(orderedSet), 'Empty ordered set is empty');
-          orderedSet.add('foo');
-          assert.equal(false, isEmpty(orderedSet), 'Ordered set is not empty');
-        },
-        'Use of @ember/OrderedSet is deprecated. Please use native `Map` instead',
-        { id: 'ember-map-deprecation', until: '3.5.0' }
-      );
-    }
-  }
-);

data/dist/es/ember-metal/tests/is_none_test.js

@@ -1,23 +0,0 @@
-import { isNone } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'isNone',
-  class extends AbstractTestCase {
-    ['@test isNone'](assert) {
-      let string = 'string';
-      let fn = function() {};
-
-      assert.equal(true, isNone(null), 'for null');
-      assert.equal(true, isNone(undefined), 'for undefined');
-      assert.equal(false, isNone(''), 'for an empty String');
-      assert.equal(false, isNone(true), 'for true');
-      assert.equal(false, isNone(false), 'for false');
-      assert.equal(false, isNone(string), 'for a String');
-      assert.equal(false, isNone(fn), 'for a Function');
-      assert.equal(false, isNone(0), 'for 0');
-      assert.equal(false, isNone([]), 'for an empty Array');
-      assert.equal(false, isNone({}), 'for an empty Object');
-    }
-  }
-);

data/dist/es/ember-metal/tests/is_present_test.js

@@ -1,30 +0,0 @@
-import { isPresent } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'isPresent',
-  class extends AbstractTestCase {
-    ['@test isPresent'](assert) {
-      let string = 'string';
-      let fn = function() {};
-      let object = { length: 0 };
-
-      assert.equal(false, isPresent(), 'for no params');
-      assert.equal(false, isPresent(null), 'for null');
-      assert.equal(false, isPresent(undefined), 'for undefined');
-      assert.equal(false, isPresent(''), 'for an empty String');
-      assert.equal(false, isPresent('  '), 'for a whitespace String');
-      assert.equal(false, isPresent('\n\t'), 'for another whitespace String');
-      assert.equal(true, isPresent('\n\t Hi'), 'for a String with whitespaces');
-      assert.equal(true, isPresent(true), 'for true');
-      assert.equal(true, isPresent(false), 'for false');
-      assert.equal(true, isPresent(string), 'for a String');
-      assert.equal(true, isPresent(fn), 'for a Function');
-      assert.equal(true, isPresent(0), 'for 0');
-      assert.equal(false, isPresent([]), 'for an empty Array');
-      assert.equal(true, isPresent({}), 'for an empty Object');
-      assert.equal(false, isPresent(object), "for an Object that has zero 'length'");
-      assert.equal(true, isPresent([1, 2, 3]), 'for a non-empty array');
-    }
-  }
-);

data/dist/es/ember-metal/tests/libraries_test.js

@@ -1,99 +0,0 @@
-/* globals EmberDev */
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-import { Libraries } from '..';
-import { EMBER_LIBRARIES_ISREGISTERED } from '@ember/canary-features';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let libs, registry;
-let originalWarn = getDebugFunction('warn');
-function noop() {}
-
-moduleFor(
-  'Libraries registry',
-  class extends AbstractTestCase {
-    beforeEach() {
-      libs = new Libraries();
-      registry = libs._registry;
-    }
-
-    afterEach() {
-      libs = null;
-      registry = null;
-
-      setDebugFunction('warn', originalWarn);
-    }
-
-    ['@test core libraries come before other libraries'](assert) {
-      assert.expect(2);
-
-      libs.register('my-lib', '2.0.0a');
-      libs.registerCoreLibrary('DS', '1.0.0-beta.2');
-
-      assert.equal(registry[0].name, 'DS');
-      assert.equal(registry[1].name, 'my-lib');
-    }
-
-    ['@test only the first registration of a library is stored'](assert) {
-      assert.expect(3);
-
-      // overwrite warn to supress the double registration warning (see https://github.com/emberjs/ember.js/issues/16391)
-      setDebugFunction('warn', noop);
-      libs.register('magic', 1.23);
-      libs.register('magic', 2.23);
-
-      assert.equal(registry[0].name, 'magic');
-      assert.equal(registry[0].version, 1.23);
-      assert.equal(registry.length, 1);
-    }
-
-    ['@test isRegistered returns correct value'](assert) {
-      if (EMBER_LIBRARIES_ISREGISTERED) {
-        assert.expect(3);
-
-        assert.equal(libs.isRegistered('magic'), false);
-
-        libs.register('magic', 1.23);
-        assert.equal(libs.isRegistered('magic'), true);
-
-        libs.deRegister('magic');
-        assert.equal(libs.isRegistered('magic'), false);
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test attempting to register a library that is already registered warns you'](assert) {
-      if (EmberDev && EmberDev.runningProdBuild) {
-        assert.ok(true, 'Logging does not occur in production builds');
-        return;
-      }
-
-      assert.expect(1);
-
-      libs.register('magic', 1.23);
-
-      setDebugFunction('warn', function(msg, test) {
-        if (!test) {
-          assert.equal(msg, 'Library "magic" is already registered with Ember.');
-        }
-      });
-
-      // Should warn us
-      libs.register('magic', 2.23);
-    }
-
-    ['@test libraries can be de-registered'](assert) {
-      assert.expect(2);
-
-      libs.register('lib1', '1.0.0b');
-      libs.register('lib2', '1.0.0b');
-      libs.register('lib3', '1.0.0b');
-
-      libs.deRegister('lib1');
-      libs.deRegister('lib3');
-
-      assert.equal(registry[0].name, 'lib2');
-      assert.equal(registry.length, 1);
-    }
-  }
-);

data/dist/es/ember-metal/tests/main_test.js

@@ -1,31 +0,0 @@
-import VERSION from 'ember/version';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-// From https://github.com/semver/semver.org/issues/59 & https://regex101.com/r/vW1jA8/6
-const SEMVER_REGEX = /^((?:0|(?:[1-9]\d*)))\.((?:0|(?:[1-9]\d*)))\.((?:0|(?:[1-9]\d*)))(?:-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?$/;
-
-moduleFor(
-  'ember-metal/core/main',
-  class extends AbstractTestCase {
-    ['@test Ember.VERSION is in alignment with SemVer v2.0.0'](assert) {
-      assert.ok(SEMVER_REGEX.test(VERSION), `Ember.VERSION (${VERSION})is valid SemVer v2.0.0`);
-    }
-
-    ['@test SEMVER_REGEX properly validates and invalidates version numbers'](assert) {
-      function validateVersionString(versionString, expectedResult) {
-        assert.equal(SEMVER_REGEX.test(versionString), expectedResult);
-      }
-
-      // Positive test cases
-      validateVersionString('1.11.3', true);
-      validateVersionString('1.0.0-beta.16.1', true);
-      validateVersionString('1.12.1+canary.aba1412', true);
-      validateVersionString('2.0.0-beta.1+canary.bb344775', true);
-      validateVersionString('3.1.0-foobarBaz+30d70bd3', true);
-
-      // Negative test cases
-      validateVersionString('1.11.3.aba18a', false);
-      validateVersionString('1.11', false);
-    }
-  }
-);