discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/container/tests/container_test.js

@@ -1,872 +0,0 @@
-import { OWNER } from 'ember-owner';
-import { assign } from '@ember/polyfills';
-import { EMBER_MODULE_UNIFICATION } from '@ember/canary-features';
-import { Registry } from '..';
-import { factory, moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Container',
-  class extends AbstractTestCase {
-    ['@test A registered factory returns the same instance each time'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.register('controller:post', PostController);
-
-      let postController = container.lookup('controller:post');
-
-      assert.ok(
-        postController instanceof PostController,
-        'The lookup is an instance of the factory'
-      );
-
-      assert.equal(postController, container.lookup('controller:post'));
-    }
-
-    ['@test uses create time injections if factory has no extend'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let AppleController = factory();
-      let PostController = factory();
-
-      PostController.extend = undefined; // remove extend
-
-      registry.register('controller:apple', AppleController);
-      registry.register('controller:post', PostController);
-      registry.injection('controller:post', 'apple', 'controller:apple');
-
-      let postController = container.lookup('controller:post');
-
-      assert.ok(
-        postController.apple instanceof AppleController,
-        'instance receives an apple of instance AppleController'
-      );
-    }
-
-    ['@test A registered factory returns a fresh instance if singleton: false is passed as an option'](
-      assert
-    ) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.register('controller:post', PostController);
-
-      let postController1 = container.lookup('controller:post');
-      let postController2 = container.lookup('controller:post', {
-        singleton: false,
-      });
-      let postController3 = container.lookup('controller:post', {
-        singleton: false,
-      });
-      let postController4 = container.lookup('controller:post');
-
-      assert.equal(
-        postController1.toString(),
-        postController4.toString(),
-        'Singleton factories looked up normally return the same value'
-      );
-      assert.notEqual(
-        postController1.toString(),
-        postController2.toString(),
-        'Singleton factories are not equal to factories looked up with singleton: false'
-      );
-      assert.notEqual(
-        postController2.toString(),
-        postController3.toString(),
-        'Two factories looked up with singleton: false are not equal'
-      );
-      assert.notEqual(
-        postController3.toString(),
-        postController4.toString(),
-        'A singleton factory looked up after a factory called with singleton: false is not equal'
-      );
-
-      assert.ok(
-        postController1 instanceof PostController,
-        'All instances are instances of the registered factory'
-      );
-      assert.ok(
-        postController2 instanceof PostController,
-        'All instances are instances of the registered factory'
-      );
-      assert.ok(
-        postController3 instanceof PostController,
-        'All instances are instances of the registered factory'
-      );
-      assert.ok(
-        postController4 instanceof PostController,
-        'All instances are instances of the registered factory'
-      );
-    }
-
-    ["@test A factory type with a registered injection's instances receive that injection"](
-      assert
-    ) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let Store = factory();
-
-      registry.register('controller:post', PostController);
-      registry.register('store:main', Store);
-
-      registry.typeInjection('controller', 'store', 'store:main');
-
-      let postController = container.lookup('controller:post');
-      let store = container.lookup('store:main');
-
-      assert.equal(postController.store, store);
-    }
-
-    ['@test An individual factory with a registered injection receives the injection'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let Store = factory();
-
-      registry.register('controller:post', PostController);
-      registry.register('store:main', Store);
-
-      registry.injection('controller:post', 'store', 'store:main');
-
-      let postController = container.lookup('controller:post');
-      let store = container.lookup('store:main');
-
-      assert.equal(postController.store, store, 'has the correct store injected');
-    }
-
-    ['@test A factory with both type and individual injections'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let Store = factory();
-      let Router = factory();
-
-      registry.register('controller:post', PostController);
-      registry.register('store:main', Store);
-      registry.register('router:main', Router);
-
-      registry.injection('controller:post', 'store', 'store:main');
-      registry.typeInjection('controller', 'router', 'router:main');
-
-      let postController = container.lookup('controller:post');
-      let store = container.lookup('store:main');
-      let router = container.lookup('router:main');
-
-      assert.equal(postController.store, store);
-      assert.equal(postController.router, router);
-    }
-
-    ['@test A non-singleton instance is never cached'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostView = factory();
-
-      registry.register('view:post', PostView, { singleton: false });
-
-      let postView1 = container.lookup('view:post');
-      let postView2 = container.lookup('view:post');
-
-      assert.ok(postView1 !== postView2, 'Non-singletons are not cached');
-    }
-
-    ['@test A non-instantiated property is not instantiated'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let template = function() {};
-      registry.register('template:foo', template, { instantiate: false });
-      assert.equal(container.lookup('template:foo'), template);
-    }
-
-    ['@test A failed lookup returns undefined'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      assert.equal(container.lookup('doesnot:exist'), undefined);
-    }
-
-    ['@test An invalid factory throws an error'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      registry.register('controller:foo', {});
-
-      assert.throws(() => {
-        container.lookup('controller:foo');
-      }, /Failed to create an instance of \'controller:foo\'/);
-    }
-
-    ['@test Injecting a failed lookup raises an error'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let fooInstance = {};
-      let fooFactory = {};
-
-      let Foo = {
-        create() {
-          return fooInstance;
-        },
-        extend() {
-          return fooFactory;
-        },
-      };
-
-      registry.register('model:foo', Foo);
-      registry.injection('model:foo', 'store', 'store:main');
-
-      assert.throws(() => {
-        container.lookup('model:foo');
-      });
-    }
-
-    ['@test Injecting a falsy value does not raise an error'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let ApplicationController = factory();
-
-      registry.register('controller:application', ApplicationController);
-      registry.register('user:current', null, { instantiate: false });
-      registry.injection('controller:application', 'currentUser', 'user:current');
-
-      assert.strictEqual(container.lookup('controller:application').currentUser, null);
-    }
-
-    ['@test The container returns same value each time even if the value is falsy'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      registry.register('falsy:value', null, { instantiate: false });
-
-      assert.strictEqual(container.lookup('falsy:value'), container.lookup('falsy:value'));
-    }
-
-    ['@test Destroying the container destroys any cached singletons'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let PostView = factory();
-      let template = function() {};
-
-      registry.register('controller:post', PostController);
-      registry.register('view:post', PostView, { singleton: false });
-      registry.register('template:post', template, { instantiate: false });
-
-      registry.injection('controller:post', 'postView', 'view:post');
-
-      let postController = container.lookup('controller:post');
-      let postView = postController.postView;
-
-      assert.ok(postView instanceof PostView, 'The non-singleton was injected');
-
-      container.destroy();
-
-      assert.ok(postController.isDestroyed, 'Singletons are destroyed');
-      assert.ok(!postView.isDestroyed, 'Non-singletons are not destroyed');
-    }
-
-    ['@test The container can use a registry hook to resolve factories lazily'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.resolver = {
-        resolve(fullName) {
-          if (fullName === 'controller:post') {
-            return PostController;
-          }
-        },
-      };
-
-      let postController = container.lookup('controller:post');
-
-      assert.ok(postController instanceof PostController, 'The correct factory was provided');
-    }
-
-    ['@test The container normalizes names before resolving'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.normalizeFullName = function() {
-        return 'controller:post';
-      };
-
-      registry.register('controller:post', PostController);
-      let postController = container.lookup('controller:normalized');
-
-      assert.ok(postController instanceof PostController, 'Normalizes the name before resolving');
-    }
-
-    ['@test The container normalizes names when looking factory up'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.normalizeFullName = function() {
-        return 'controller:post';
-      };
-
-      registry.register('controller:post', PostController);
-      let fact = container.factoryFor('controller:normalized');
-
-      let factInstance = fact.create();
-      assert.ok(factInstance instanceof PostController, 'Normalizes the name');
-    }
-
-    ['@test Options can be registered that should be applied to a given factory'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostView = factory();
-
-      registry.resolver = {
-        resolve(fullName) {
-          if (fullName === 'view:post') {
-            return PostView;
-          }
-        },
-      };
-
-      registry.options('view:post', { instantiate: true, singleton: false });
-
-      let postView1 = container.lookup('view:post');
-      let postView2 = container.lookup('view:post');
-
-      assert.ok(postView1 instanceof PostView, 'The correct factory was provided');
-      assert.ok(postView2 instanceof PostView, 'The correct factory was provided');
-
-      assert.ok(postView1 !== postView2, 'The two lookups are different');
-    }
-
-    ['@test Options can be registered that should be applied to all factories for a given type'](
-      assert
-    ) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostView = factory();
-
-      registry.resolver = {
-        resolve(fullName) {
-          if (fullName === 'view:post') {
-            return PostView;
-          }
-        },
-      };
-
-      registry.optionsForType('view', { singleton: false });
-
-      let postView1 = container.lookup('view:post');
-      let postView2 = container.lookup('view:post');
-
-      assert.ok(postView1 instanceof PostView, 'The correct factory was provided');
-      assert.ok(postView2 instanceof PostView, 'The correct factory was provided');
-
-      assert.ok(postView1 !== postView2, 'The two lookups are different');
-    }
-
-    ['@test An injected non-singleton instance is never cached'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostView = factory();
-      let PostViewHelper = factory();
-
-      registry.register('view:post', PostView, { singleton: false });
-      registry.register('view_helper:post', PostViewHelper, {
-        singleton: false,
-      });
-      registry.injection('view:post', 'viewHelper', 'view_helper:post');
-
-      let postView1 = container.lookup('view:post');
-      let postView2 = container.lookup('view:post');
-
-      assert.ok(
-        postView1.viewHelper !== postView2.viewHelper,
-        'Injected non-singletons are not cached'
-      );
-    }
-
-    ['@test Factory resolves are cached'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let resolveWasCalled = [];
-      registry.resolve = function(fullName) {
-        resolveWasCalled.push(fullName);
-        return PostController;
-      };
-
-      assert.deepEqual(resolveWasCalled, []);
-      container.factoryFor('controller:post');
-      assert.deepEqual(resolveWasCalled, ['controller:post']);
-
-      container.factoryFor('controller:post');
-      assert.deepEqual(resolveWasCalled, ['controller:post']);
-    }
-
-    ['@test factory for non extendables (MODEL) resolves are cached'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-      let resolveWasCalled = [];
-      registry.resolve = function(fullName) {
-        resolveWasCalled.push(fullName);
-        return PostController;
-      };
-
-      assert.deepEqual(resolveWasCalled, []);
-      container.factoryFor('model:post');
-      assert.deepEqual(resolveWasCalled, ['model:post']);
-
-      container.factoryFor('model:post');
-      assert.deepEqual(resolveWasCalled, ['model:post']);
-    }
-
-    ['@test factory for non extendables resolves are cached'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = {};
-      let resolveWasCalled = [];
-
-      registry.resolve = function(fullName) {
-        resolveWasCalled.push(fullName);
-        return PostController;
-      };
-
-      assert.deepEqual(resolveWasCalled, []);
-      container.factoryFor('foo:post');
-      assert.deepEqual(resolveWasCalled, ['foo:post']);
-
-      container.factoryFor('foo:post');
-      assert.deepEqual(resolveWasCalled, ['foo:post']);
-    }
-
-    [`@test A factory's lazy injections are validated when first instantiated`](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let Apple = factory();
-      let Orange = factory();
-
-      Apple.reopenClass({
-        _lazyInjections() {
-          return [{ specifier: 'orange:main' }, { specifier: 'banana:main' }];
-        },
-      });
-
-      registry.register('apple:main', Apple);
-      registry.register('orange:main', Orange);
-
-      assert.throws(() => {
-        container.lookup('apple:main');
-      }, /Attempting to inject an unknown injection: 'banana:main'/);
-    }
-
-    ['@test Lazy injection validations are cached'](assert) {
-      assert.expect(1);
-
-      let registry = new Registry();
-      let container = registry.container();
-      let Apple = factory();
-      let Orange = factory();
-
-      Apple.reopenClass({
-        _lazyInjections: () => {
-          assert.ok(true, 'should call lazy injection method');
-          return [{ specifier: 'orange:main' }];
-        },
-      });
-
-      registry.register('apple:main', Apple);
-      registry.register('orange:main', Orange);
-
-      container.lookup('apple:main');
-      container.lookup('apple:main');
-    }
-
-    ['@test An object with its owner pre-set should be returned from ownerInjection'](assert) {
-      let owner = {};
-      let registry = new Registry();
-      let container = registry.container({ owner });
-
-      let result = container.ownerInjection();
-
-      assert.equal(result[OWNER], owner, 'owner is properly included');
-    }
-
-    ['@test lookup passes options through to expandlocallookup'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let PostController = factory();
-
-      registry.register('controller:post', PostController);
-      registry.expandLocalLookup = (fullName, options) => {
-        assert.ok(true, 'expandLocalLookup was called');
-        assert.equal(fullName, 'foo:bar');
-        assert.deepEqual(options, { source: 'baz:qux' });
-
-        return 'controller:post';
-      };
-
-      let PostControllerLookupResult = container.lookup('foo:bar', {
-        source: 'baz:qux',
-      });
-
-      assert.ok(PostControllerLookupResult instanceof PostController);
-    }
-
-    ['@test #factoryFor class is registered class'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-
-      let factoryManager = container.factoryFor('component:foo-bar');
-      assert.deepEqual(factoryManager.class, Component, 'No double extend');
-    }
-
-    ['@test #factoryFor must supply a fullname']() {
-      let registry = new Registry();
-      let container = registry.container();
-      expectAssertion(() => {
-        container.factoryFor('chad-bar');
-      }, /fullName must be a proper full name/);
-    }
-
-    ['@test #factoryFor returns a factory manager'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-
-      let factoryManager = container.factoryFor('component:foo-bar');
-      assert.ok(factoryManager.create);
-      assert.ok(factoryManager.class);
-    }
-
-    ['@test #factoryFor returns a cached factory manager for the same type'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-      registry.register('component:baz-bar', Component);
-
-      let factoryManager1 = container.factoryFor('component:foo-bar');
-      let factoryManager2 = container.factoryFor('component:foo-bar');
-      let factoryManager3 = container.factoryFor('component:baz-bar');
-
-      assert.equal(factoryManager1, factoryManager2, 'cache hit');
-      assert.notEqual(factoryManager1, factoryManager3, 'cache miss');
-    }
-
-    ['@test #factoryFor class returns the factory function'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-
-      let factoryManager = container.factoryFor('component:foo-bar');
-      assert.deepEqual(factoryManager.class, Component, 'No double extend');
-    }
-
-    ['@test #factoryFor instance have a common parent'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-
-      let factoryManager1 = container.factoryFor('component:foo-bar');
-      let factoryManager2 = container.factoryFor('component:foo-bar');
-      let instance1 = factoryManager1.create({ foo: 'foo' });
-      let instance2 = factoryManager2.create({ bar: 'bar' });
-
-      assert.deepEqual(instance1.constructor, instance2.constructor);
-    }
-
-    ['@test can properly reset cache'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-
-      let factory1 = container.factoryFor('component:foo-bar');
-      let factory2 = container.factoryFor('component:foo-bar');
-
-      let instance1 = container.lookup('component:foo-bar');
-      let instance2 = container.lookup('component:foo-bar');
-
-      assert.equal(instance1, instance2);
-      assert.equal(factory1, factory2);
-
-      container.reset();
-
-      let factory3 = container.factoryFor('component:foo-bar');
-      let instance3 = container.lookup('component:foo-bar');
-
-      assert.notEqual(instance1, instance3);
-      assert.notEqual(factory1, factory3);
-    }
-
-    ['@test #factoryFor created instances come with instance injections'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      let Ajax = factory();
-      registry.register('component:foo-bar', Component);
-      registry.register('util:ajax', Ajax);
-      registry.injection('component:foo-bar', 'ajax', 'util:ajax');
-
-      let componentFactory = container.factoryFor('component:foo-bar');
-      let component = componentFactory.create();
-
-      assert.ok(component.ajax);
-      assert.ok(component.ajax instanceof Ajax);
-    }
-
-    ['@test #factoryFor options passed to create clobber injections'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      let Component = factory();
-      let Ajax = factory();
-      registry.register('component:foo-bar', Component);
-      registry.register('util:ajax', Ajax);
-      registry.injection('component:foo-bar', 'ajax', 'util:ajax');
-
-      let componentFactory = container.factoryFor('component:foo-bar');
-      let instrance = componentFactory.create({ ajax: 'fetch' });
-
-      assert.equal(instrance.ajax, 'fetch');
-    }
-
-    ['@test #factoryFor does not add properties to the object being instantiated when _initFactory is present'](
-      assert
-    ) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      class Component {
-        static _initFactory() {}
-        static create(options) {
-          let instance = new this();
-          assign(instance, options);
-          return instance;
-        }
-      }
-      registry.register('component:foo-bar', Component);
-
-      let componentFactory = container.factoryFor('component:foo-bar');
-      let instance = componentFactory.create();
-
-      // note: _guid and isDestroyed are being set in the `factory` constructor
-      // not via registry/container shenanigans
-      assert.deepEqual(Object.keys(instance), []);
-    }
-
-    [`@test assert when calling lookup after destroy on a container`](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-      let instance = container.lookup('component:foo-bar');
-      assert.ok(instance, 'precond lookup successful');
-
-      this.runTask(() => {
-        container.destroy();
-        container.finalizeDestroy();
-      });
-
-      expectAssertion(() => {
-        container.lookup('component:foo-bar');
-      });
-    }
-
-    [`@test assert when calling factoryFor after destroy on a container`](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-      let Component = factory();
-      registry.register('component:foo-bar', Component);
-      let instance = container.factoryFor('component:foo-bar');
-      assert.ok(instance, 'precond lookup successful');
-
-      this.runTask(() => {
-        container.destroy();
-        container.finalizeDestroy();
-      });
-
-      expectAssertion(() => {
-        container.factoryFor('component:foo-bar');
-      });
-    }
-
-    // this is skipped until templates and the glimmer environment do not require `OWNER` to be
-    // passed in as constructor args
-    ['@skip #factoryFor does not add properties to the object being instantiated'](assert) {
-      let registry = new Registry();
-      let container = registry.container();
-
-      class Component {
-        static create(options) {
-          let instance = new this();
-          assign(instance, options);
-          return instance;
-        }
-      }
-      registry.register('component:foo-bar', Component);
-
-      let componentFactory = container.factoryFor('component:foo-bar');
-      let instance = componentFactory.create();
-
-      // note: _guid and isDestroyed are being set in the `factory` constructor
-      // not via registry/container shenanigans
-      assert.deepEqual(Object.keys(instance), []);
-    }
-  }
-);
-
-if (EMBER_MODULE_UNIFICATION) {
-  moduleFor(
-    'Container module unification',
-    class extends AbstractTestCase {
-      ['@test The container can expand and resolve a source to factoryFor'](assert) {
-        let PrivateComponent = factory();
-        let lookup = 'component:my-input';
-        let expectedSource = 'template:routes/application';
-        let registry = new Registry();
-        let resolveCount = 0;
-        let expandedKey = 'boom, special expanded key';
-        registry.expandLocalLookup = (specifier, options) => {
-          this.assert.strictEqual(specifier, lookup, 'specifier is expanded');
-          this.assert.strictEqual(options.source, expectedSource, 'source is expanded');
-          return expandedKey;
-        };
-        registry.resolve = function(fullName) {
-          resolveCount++;
-          if (fullName === expandedKey) {
-            return PrivateComponent;
-          }
-        };
-
-        let container = registry.container();
-
-        assert.strictEqual(
-          container.factoryFor(lookup, { source: expectedSource }).class,
-          PrivateComponent,
-          'The correct factory was provided'
-        );
-        assert.strictEqual(
-          container.factoryFor(lookup, { source: expectedSource }).class,
-          PrivateComponent,
-          'The correct factory was provided again'
-        );
-        assert.equal(
-          resolveCount,
-          1,
-          'resolve called only once and a cached factory was returned the second time'
-        );
-      }
-
-      ['@test The container can expand and resolve a source to lookup']() {
-        let PrivateComponent = factory();
-        let lookup = 'component:my-input';
-        let expectedSource = 'template:routes/application';
-        let registry = new Registry();
-        let expandedKey = 'boom, special expanded key';
-        registry.expandLocalLookup = (specifier, options) => {
-          this.assert.strictEqual(specifier, lookup, 'specifier is expanded');
-          this.assert.strictEqual(options.source, expectedSource, 'source is expanded');
-          return expandedKey;
-        };
-        registry.resolve = function(fullName) {
-          if (fullName === expandedKey) {
-            return PrivateComponent;
-          }
-        };
-
-        let container = registry.container();
-
-        let result = container.lookup(lookup, { source: expectedSource });
-        this.assert.ok(result instanceof PrivateComponent, 'The correct factory was provided');
-
-        this.assert.ok(
-          container.cache[expandedKey] instanceof PrivateComponent,
-          'The correct factory was stored in the cache with the correct key which includes the source.'
-        );
-      }
-
-      ['@test The container can expand and resolve a namespace to factoryFor'](assert) {
-        let PrivateComponent = factory();
-        let lookup = 'component:my-input';
-        let expectedNamespace = 'my-addon';
-        let registry = new Registry();
-        let resolveCount = 0;
-        let expandedKey = 'boom, special expanded key';
-        registry.expandLocalLookup = (specifier, options) => {
-          this.assert.strictEqual(specifier, lookup, 'specifier is expanded');
-          this.assert.strictEqual(options.namespace, expectedNamespace, 'namespace is expanded');
-          return expandedKey;
-        };
-        registry.resolve = function(fullName) {
-          resolveCount++;
-          if (fullName === expandedKey) {
-            return PrivateComponent;
-          }
-        };
-
-        let container = registry.container();
-
-        assert.strictEqual(
-          container.factoryFor(lookup, { namespace: expectedNamespace }).class,
-          PrivateComponent,
-          'The correct factory was provided'
-        );
-        assert.strictEqual(
-          container.factoryFor(lookup, { namespace: expectedNamespace }).class,
-          PrivateComponent,
-          'The correct factory was provided again'
-        );
-        assert.equal(
-          resolveCount,
-          1,
-          'resolve called only once and a cached factory was returned the second time'
-        );
-      }
-
-      ['@test The container can expand and resolve a namespace to lookup']() {
-        let PrivateComponent = factory();
-        let lookup = 'component:my-input';
-        let expectedNamespace = 'my-addon';
-        let registry = new Registry();
-        let expandedKey = 'boom, special expanded key';
-        registry.expandLocalLookup = (specifier, options) => {
-          this.assert.strictEqual(specifier, lookup, 'specifier is expanded');
-          this.assert.strictEqual(options.namespace, expectedNamespace, 'namespace is expanded');
-          return expandedKey;
-        };
-        registry.resolve = function(fullName) {
-          if (fullName === expandedKey) {
-            return PrivateComponent;
-          }
-        };
-
-        let container = registry.container();
-
-        let result = container.lookup(lookup, { namespace: expectedNamespace });
-        this.assert.ok(result instanceof PrivateComponent, 'The correct factory was provided');
-
-        this.assert.ok(
-          container.cache[expandedKey] instanceof PrivateComponent,
-          'The correct factory was stored in the cache with the correct key which includes the source.'
-        );
-      }
-    }
-  );
-}