Add option to render to enable improved ember-engines testing API

addon-test-support/@ember/test-helpers/setup-rendering-context.ts

@@ -69,14 +69,29 @@ function lookupOutletTemplate(owner: Owner): any {
 }
 
 let templateId = 0;
+
+export interface RenderOptions {
+  /**
+    The owner object to use as the basis for the template. In most cases you
+    will not need to specify this, however if you are using ember-engines
+    it is possible to specify the _engine's_ owner instead of the host
+    applications.
+  */
+  owner?: Owner;
+}
+
 /**
   Renders the provided template and appends it to the DOM.
 
   @public
   @param {CompiledTemplate} template the template to render
+  @param {RenderOptions} options options hash containing engine owner ({ owner: engineOwner })
   @returns {Promise<void>} resolves when settled
 */
-export function render(template: TemplateFactory): Promise<void> {
+export function render(
+  template: TemplateFactory,
+  options?: RenderOptions
+): Promise<void> {
   let context = getContext();
 
   if (!template) {
@@ -98,13 +113,15 @@ export function render(template: TemplateFactory): Promise<void> {
 
       let toplevelView = owner.lookup('-top-level-view:main');
       let OutletTemplate = lookupOutletTemplate(owner);
+      let ownerToRenderFrom = options?.owner || owner;
+
       templateId += 1;
       let templateFullName = `template:-undertest-${templateId}`;
-      owner.register(templateFullName, template);
+      ownerToRenderFrom.register(templateFullName, template);
 
       let outletState = {
         render: {
-          owner,
+          owner, // always use the host app owner for application outlet
           into: undefined,
           outlet: 'main',
           name: 'application',
@@ -116,13 +133,13 @@ export function render(template: TemplateFactory): Promise<void> {
         outlets: {
           main: {
             render: {
-              owner,
+              owner: ownerToRenderFrom, // the actual owner to be used for any lookups
               into: undefined,
               outlet: 'main',
               name: 'index',
               controller: context,
               ViewClass: undefined,
-              template: lookupTemplate(owner, templateFullName),
+              template: lookupTemplate(ownerToRenderFrom, templateFullName),
               outlets: {},
             },
             outlets: {},

tests/unit/setup-rendering-context-test.js

@@ -5,6 +5,7 @@ import Component from '@ember/component';
 import TextField from '@ember/component/text-field';
 import { helper } from '@ember/component/helper';
 import {
+  getApplication,
   setupContext,
   setupRenderingContext,
   teardownContext,
@@ -28,6 +29,36 @@ import {
 } from '../helpers/resolver';
 import { hbs } from 'ember-cli-htmlbars';
 import { getOwner } from '@ember/application';
+import Engine from '@ember/engine';
+
+async function buildEngineOwner(parentOwner, registry) {
+  parentOwner.register(
+    'engine:foo',
+    Engine.extend({
+      router: null,
+
+      Resolver: {
+        create() {
+          return {
+            registry,
+            resolve(fullName) {
+              return registry[fullName];
+            },
+          };
+        },
+      },
+    })
+  );
+
+  let instance = parentOwner.buildChildEngineInstance('foo', {
+    routable: true,
+    mountPoint: 'foo',
+  });
+
+  await instance.boot();
+
+  return instance;
+}
 
 module('setupRenderingContext', function (hooks) {
   if (!hasEmberVersion(2, 4)) {
@@ -74,6 +105,26 @@ module('setupRenderingContext', function (hooks) {
       assert.equal(this.element.textContent, 'Hi!');
     });
 
+    test('render works with custom owner', async function (assert) {
+      if (getApplication() === null) {
+        assert.ok(
+          true,
+          'cannot test custom owner when no root application is set'
+        );
+        return;
+      }
+
+      let alternateOwner = await buildEngineOwner(this.owner, {
+        'template:components/foo': hbs`hello!`,
+      });
+
+      this.owner.register('template:components/foo', hbs`noooooooo!`);
+
+      await render(hbs`<Foo />`, { owner: alternateOwner });
+
+      assert.equal(this.element.textContent, 'hello!');
+    });
+
     if (EmberENV._APPLICATION_TEMPLATE_WRAPPER !== false) {
       test('render exposes an `.element` property with application template wrapper', async function (assert) {
         let rootElement = document.getElementById('ember-testing');