Expose TaskInstance state inside encapsulated tasks

While TaskInstance state was exposed externally via proxying,
the proxy was not used internally making TaskInstance state
impossible to access.

Author: maxfierke

addon/-private/task.js

@@ -289,6 +289,7 @@ if (TRACKED_INITIAL_TASK_STATE) {
 
 Object.assign(Task.prototype, TASKABLE_MIXIN);
 
+const currentTaskInstanceSymbol = '__ec__encap_current_ti';
 export class EncapsulatedTask extends Task {
   constructor(options) {
     super(options);
@@ -297,15 +298,31 @@ export class EncapsulatedTask extends Task {
     this._encapsulatedTaskInstanceProxies = new WeakMap();
   }
 
+  _getEncapsulatedTaskClass() {
+    let encapsulatedTaskImplClass = this._encapsulatedTaskImplClass;
+
+    if (!encapsulatedTaskImplClass) {
+      encapsulatedTaskImplClass = EmberObject.extend(this.taskObj, {
+        unknownProperty(key) {
+          let currentInstance = this[currentTaskInstanceSymbol];
+          return currentInstance ? currentInstance[key] : undefined;
+        },
+      });
+    }
+
+    return encapsulatedTaskImplClass;
+  }
+
   _taskInstanceFactory(args, performType) {
     let owner = getOwner(this.context);
-    let encapsulatedTaskImpl = EmberObject.extend(this.taskObj).create({
+    let taskInstanceProxy;
+    let encapsulatedTaskImpl = this._getEncapsulatedTaskClass().create({
       context: this.context,
     });
     setOwner(encapsulatedTaskImpl, owner);
 
     let generatorFactory = () =>
-      encapsulatedTaskImpl.perform.apply(encapsulatedTaskImpl, args);
+      encapsulatedTaskImpl.perform.apply(taskInstanceProxy, args);
     let taskInstance = new TaskInstance({
       task: this,
       args,
@@ -317,10 +334,13 @@ export class EncapsulatedTask extends Task {
       performType,
       hasEnabledEvents: this.hasEnabledEvents,
     });
+    encapsulatedTaskImpl[currentTaskInstanceSymbol] = taskInstance;
 
     this._encapsulatedTaskStates.set(taskInstance, encapsulatedTaskImpl);
 
-    return this._wrappedEncapsulatedTaskInstance(taskInstance);
+    taskInstanceProxy = this._wrappedEncapsulatedTaskInstance(taskInstance);
+
+    return taskInstanceProxy;
   }
 
   _wrappedEncapsulatedTaskInstance(taskInstance) {

tests/unit/encapsulated-task-test.js

@@ -1,6 +1,7 @@
 import { run } from '@ember/runloop';
 import RSVP from 'rsvp';
 import EmberObject from '@ember/object';
+import { reads } from '@ember/object/computed';
 import { task } from 'ember-concurrency';
 import { module, test } from 'qunit';
 import { decoratorTest } from '../helpers/helpers';
@@ -85,6 +86,31 @@ module('Unit: EncapsulatedTask', function () {
     assert.equal(value, 'pickle');
   });
 
+  test('encapsulated tasks can access task instance context', async function (assert) {
+    assert.expect(2);
+
+    let defer;
+    let Obj = EmberObject.extend({
+      myTask: task({
+        amIRunning: reads('isRunning'),
+
+        *perform() {
+          defer = RSVP.defer();
+          yield defer.promise;
+          return 'blah';
+        },
+      }),
+    });
+
+    let obj = Obj.create();
+    const taskInstance = obj.get('myTask').perform();
+    assert.equal(taskInstance.amIRunning, true);
+
+    defer.resolve();
+    await taskInstance;
+    assert.equal(taskInstance.amIRunning, false);
+  });
+
   decoratorTest(
     'encapsulated tasks work with native ES classes and decorators',
     function (assert) {