Pass owner to constructor.

addon/component-managers/sparkles.ts

@@ -3,6 +3,7 @@ import { getOwner, setOwner } from '@ember/application';
 import ApplicationInstance from '@ember/application/instance';
 import { capabilities } from '@ember/component';
 import SparklesComponent from 'sparkles-component';
+import { deprecate } from '@ember/debug';
 
 export interface ComponentManagerArgs {
   named: object;
@@ -16,17 +17,24 @@ export default class SparklesComponentManager {
     return new this(owner);
   }
   capabilities: any;
-  constructor(owner: ApplicationInstance) {
-    setOwner(this, owner);
+  constructor(private owner: ApplicationInstance) {
     this.capabilities = capabilities('3.4', {
       destructor: true,
       asyncLifecycleCallbacks: true,
     });
   }
 
   createComponent(Klass: typeof SparklesComponent, args: ComponentManagerArgs): CreateComponentResult {
-    let instance = new Klass(args.named);
-    setOwner(instance, getOwner(this));
+    let { owner } = this;
+
+    let instance = new Klass(args.named, owner);
+
+    // check to make sure that owner was properly set, this ensures `super(...arguments)` was called
+    if (getOwner(instance) !== owner) {
+      deprecate(`must call super with all arguments in the constructor for ${Klass.name}`, false, { id: 'sparkles-component.super-arguments', until: '2.0.0' });
+      setOwner(instance, owner);
+    }
+
     return instance as CreateComponentResult;
   }
 

addon/index.ts

@@ -1,7 +1,12 @@
 import { setComponentManager } from '@ember/component';
+import { setOwner } from '@ember/application';
 
 class SparklesComponent<T = object> {
-  constructor(public args: T) {}
+  constructor(public args: T, owner: any | undefined) {
+    if (owner) {
+      setOwner(this, owner);
+    }
+  }
 
   didInsertElement() {}
   didUpdate() {}

tests/integration/components/sparkles-component-test.js

@@ -4,6 +4,7 @@ import { setupRenderingTest } from 'ember-qunit';
 import { render, clearRender, click } from '@ember/test-helpers';
 import hbs from 'htmlbars-inline-precompile';
 import { getOwner } from '@ember/application';
+import Service from '@ember/service';
 
 module('Integration | Component | sparkles-component', function(hooks) {
   let InstrumentedComponent;
@@ -118,6 +119,26 @@ module('Integration | Component | sparkles-component', function(hooks) {
     assert.dom('p').hasText('HELLO!');
   });
 
+  test('it can access injections in constructor', async function(assert) {
+    this.owner.register('service:something', Service.extend({
+      someMethod() { return 'it works!'; }
+    }));
+    class ComponentUnderTest extends SparklesComponent {
+      constructor() {
+        super(...arguments);
+
+        let owner = getOwner(this);
+        let something = owner.lookup('service:something');
+        this.text = something.someMethod();
+      }
+    }
+    this.owner.register('component:under-test', ComponentUnderTest);
+    this.owner.register('template:components/under-test', hbs`<p>{{this.text}}</p>`);
+
+    await render(hbs`<UnderTest />`);
+    assert.dom('p').hasText('it works!');
+  });
+
   test('it can use tracked to recompute when args change', async function(assert) {
     this.owner.register('component:under-test', class extends SparklesComponent {
       @tracked('args')
@@ -221,5 +242,24 @@ module('Integration | Component | sparkles-component', function(hooks) {
     );
     await render(hbs`<UnderTest />`);
     assert.dom('p').hasText('Environment: test');
-  })
+  });
+
+  test('not calling super with all arguments issues deprecation', async function(assert) {
+    this.owner.register('component:under-test', class UnderTest extends SparklesComponent {
+      constructor(args) {
+        super(args);
+      }
+      get environment() {
+        return getOwner(this).resolveRegistration("config:environment").environment;
+      }
+    });
+    this.owner.register(
+      'template:components/under-test',
+      hbs`<p>Environment: {{this.environment}}</p>`
+    );
+    await render(hbs`<UnderTest />`);
+    assert.dom('p').hasText('Environment: test');
+
+    assert.deprecationsInclude(`must call super with all arguments in the constructor for UnderTest`);
+  });
 });

tests/integration/components/tracked-ts-test.ts

@@ -80,8 +80,8 @@ module('tracked: ts', function(hooks) {
     class UnderTest extends SparklesComponent {
       _value: number;
 
-      constructor(arg: {}) {
-        super(arg);
+      constructor(args: {}, owner: any) {
+        super(args, owner);
         this._value = 0;
       }
 

tests/test-helper.js

@@ -2,8 +2,53 @@ import Application from '../app';
 import config from '../config/environment';
 import { setApplication } from '@ember/test-helpers';
 import { start } from 'ember-qunit';
+import { registerDeprecationHandler } from '@ember/debug';
+import QUnit from 'qunit';
 import 'qunit-dom';
 
 setApplication(Application.create(config.APP));
 
 start();
+
+let deprecations;
+registerDeprecationHandler((message, options, next) => {
+  // in case a deprecation is issued before a test is started
+  if (!deprecations) {
+    deprecations = [];
+  }
+
+  deprecations.push(message);
+  next(message, options);
+});
+
+QUnit.testStart(function() {
+  deprecations = [];
+});
+
+QUnit.assert.noDeprecations = function(callback) {
+  let originalDeprecations = deprecations;
+  deprecations = [];
+
+  callback();
+  this.deepEqual(deprecations, [], 'Expected no deprecations during test.');
+
+  deprecations = originalDeprecations;
+};
+
+QUnit.assert.deprecations = function(callback, expectedDeprecations) {
+  let originalDeprecations = deprecations;
+  deprecations = [];
+
+  callback();
+  this.deepEqual(deprecations, expectedDeprecations, 'Expected deprecations during test.');
+
+  deprecations = originalDeprecations;
+};
+
+QUnit.assert.deprecationsInclude = function(expected) {
+  this.pushResult({
+    result: deprecations.indexOf(expected) > -1,
+    actual: deprecations,
+    message: `expected to find \`${expected}\` deprecation`,
+  });
+};