Deprecate Ember.DeferredMixin and Ember.Deferred.

packages/ember-application/lib/system/application.js

@@ -181,6 +181,7 @@ var ContainerDebugAdapter;
 */
 
 var Application = Namespace.extend(DeferredMixin, {
+  _suppressDeferredDeprecation: true,
 
   /**
     The root DOM element of the Application. This can be specified as an
@@ -760,6 +761,17 @@ var Application = Namespace.extend(DeferredMixin, {
 
   initializer: function(options) {
     this.constructor.initializer(options);
+  },
+
+  /**
+    @method then
+    @private
+    @deprecated
+  */
+  then: function() {
+    Ember.deprecate('Do not use `.then` on an instance of Ember.Application.  Please use the `.ready` hook instead.');
+
+    this._super.apply(this, arguments);
   }
 });
 

packages/ember-application/tests/system/application_test.js

@@ -284,3 +284,15 @@ test("can resolve custom router", function(){
 
   ok(app.__container__.lookup('router:main') instanceof CustomRouter, 'application resolved the correct router');
 });
+
+test("throws helpful error if `app.then` is used", function() {
+  run(function() {
+    app = Application.create({
+      rootElement: '#qunit-fixture'
+    });
+  });
+
+  expectDeprecation(function() {
+    run(app, 'then', Ember.K);
+  }, /Do not use `.then` on an instance of Ember.Application.  Please use the `.ready` hook instead./);
+});

packages/ember-application/tests/system/readiness_test.js

@@ -60,87 +60,60 @@ QUnit.module("Application readiness", {
 // it was triggered after initialization.
 
 test("Ember.Application's ready event is called right away if jQuery is already ready", function() {
-  var wasResolved = 0;
   jQuery.isReady = true;
 
   run(function() {
     application = Application.create({ router: false });
-    application.then(function() {
-      wasResolved++;
-    });
 
     equal(readyWasCalled, 0, "ready is not called until later");
-    equal(wasResolved, 0);
   });
 
-  equal(wasResolved, 1);
   equal(readyWasCalled, 1, "ready was called");
 
   domReady();
 
-  equal(wasResolved, 1);
   equal(readyWasCalled, 1, "application's ready was not called again");
 });
 
 test("Ember.Application's ready event is called after the document becomes ready", function() {
-  var wasResolved = 0;
   run(function() {
     application = Application.create({ router: false });
-    application.then(function() {
-      wasResolved++;
-    });
-    equal(wasResolved, 0);
   });
 
   equal(readyWasCalled, 0, "ready wasn't called yet");
-  equal(wasResolved, 0);
 
   domReady();
 
-  equal(wasResolved, 1);
   equal(readyWasCalled, 1, "ready was called now that DOM is ready");
 });
 
 test("Ember.Application's ready event can be deferred by other components", function() {
-  var wasResolved = 0;
-
   run(function() {
     application = Application.create({ router: false });
-    application.then(function() {
-      wasResolved++;
-    });
     application.deferReadiness();
-    equal(wasResolved, 0);
   });
 
   equal(readyWasCalled, 0, "ready wasn't called yet");
 
   domReady();
 
   equal(readyWasCalled, 0, "ready wasn't called yet");
-  equal(wasResolved, 0);
 
   run(function() {
     application.advanceReadiness();
     equal(readyWasCalled, 0);
-    equal(wasResolved, 0);
   });
 
-  equal(wasResolved, 1);
   equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
 });
 
 test("Ember.Application's ready event can be deferred by other components", function() {
-  var wasResolved = 0;
   jQuery.isReady = false;
 
   run(function() {
     application = Application.create({ router: false });
     application.deferReadiness();
-    application.then(function() {
-      wasResolved++;
-    });
-    equal(wasResolved, 0);
+    equal(readyWasCalled, 0, "ready wasn't called yet");
   });
 
   domReady();
@@ -149,10 +122,8 @@ test("Ember.Application's ready event can be deferred by other components", func
 
   run(function() {
     application.advanceReadiness();
-    equal(wasResolved, 0);
   });
 
-  equal(wasResolved, 1);
   equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
 
   expectAssertion(function() {

packages/ember-application/tests/system/reset_test.js

@@ -29,12 +29,13 @@ QUnit.module("Ember.Application - resetting", {
 
 test("Brings it's own run-loop if not provided", function() {
   application = run(Application, 'create');
+  application.ready = function() {
+    QUnit.start();
+    ok(true, 'app booted');
+  };
 
+  QUnit.stop();
   application.reset();
-
-  run(application,'then', function() {
-    ok(true, 'app booted');
-  });
 });
 
 test("does not bring it's own run loop if one is already provided", function() {

packages/ember-runtime/lib/ext/rsvp.js

@@ -2,10 +2,39 @@
 
 import Ember from 'ember-metal/core';
 import Logger from 'ember-metal/logger';
+import run from "ember-metal/run_loop";
 
 var RSVP = requireModule('rsvp');
 var Test, testModuleName = 'ember-testing/test';
 
+var asyncStart = function() {
+  if (Ember.Test && Ember.Test.adapter) {
+    Ember.Test.adapter.asyncStart();
+  }
+};
+
+var asyncEnd = function() {
+  if (Ember.Test && Ember.Test.adapter) {
+    Ember.Test.adapter.asyncEnd();
+  }
+};
+
+RSVP.configure('async', function(callback, promise) {
+  var async = !run.currentRunLoop;
+
+  if (Ember.testing && async) { asyncStart(); }
+
+  run.backburner.schedule('actions', function(){
+    if (Ember.testing && async) { asyncEnd(); }
+    callback(promise);
+  });
+});
+
+RSVP.Promise.prototype.fail = function(callback, label){
+  Ember.deprecate('RSVP.Promise.fail has been renamed as RSVP.Promise.catch');
+  return this['catch'](callback, label);
+};
+
 RSVP.onerrorDefault = function (error) {
   if (error instanceof Error) {
     if (Ember.testing) {

packages/ember-runtime/lib/mixins/deferred.js

@@ -2,37 +2,8 @@ import Ember from "ember-metal/core"; // Ember.FEATURES, Ember.Test
 import { get } from "ember-metal/property_get";
 import { Mixin } from "ember-metal/mixin";
 import { computed } from "ember-metal/computed";
-import run from "ember-metal/run_loop";
 import RSVP from "ember-runtime/ext/rsvp";
 
-var asyncStart = function() {
-  if (Ember.Test && Ember.Test.adapter) {
-    Ember.Test.adapter.asyncStart();
-  }
-};
-
-var asyncEnd = function() {
-  if (Ember.Test && Ember.Test.adapter) {
-    Ember.Test.adapter.asyncEnd();
-  }
-};
-
-RSVP.configure('async', function(callback, promise) {
-  var async = !run.currentRunLoop;
-
-  if (Ember.testing && async) { asyncStart(); }
-
-  run.backburner.schedule('actions', function(){
-    if (Ember.testing && async) { asyncEnd(); }
-    callback(promise);
-  });
-});
-
-RSVP.Promise.prototype.fail = function(callback, label){
-  Ember.deprecate('RSVP.Promise.fail has been renamed as RSVP.Promise.catch');
-  return this['catch'](callback, label);
-};
-
 /**
 @module ember
 @submodule ember-runtime
@@ -97,6 +68,8 @@ export default Mixin.create({
   },
 
   _deferred: computed(function() {
+    Ember.deprecate('Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.', this._suppressDeferredDeprecation);
+
     return RSVP.defer('Ember: DeferredMixin - ' + this);
   })
 });

packages/ember-runtime/lib/system/deferred.js

@@ -1,8 +1,14 @@
+import Ember from 'ember-metal/core';
 import DeferredMixin from "ember-runtime/mixins/deferred";
 import {get} from "ember-metal/property_get";
 import EmberObject from "ember-runtime/system/object";
 
-var Deferred = EmberObject.extend(DeferredMixin);
+var Deferred = EmberObject.extend(DeferredMixin, {
+  init: function() {
+    Ember.deprecate('Usage of Ember.Deferred is deprecated.');
+    this._super();
+  }
+});
 
 Deferred.reopenClass({
   promise: function(callback, binding) {

packages/ember-runtime/tests/ext/rsvp_test.js

@@ -1,3 +1,5 @@
+/* global Promise:true */
+
 import run from "ember-metal/run_loop";
 import RSVP from "ember-runtime/ext/rsvp";
 
@@ -17,3 +19,92 @@ test('Ensure that errors thrown from within a promise are sent to the console',
     equal(e, error, "error was re-thrown");
   }
 });
+
+var asyncStarted = 0;
+var asyncEnded = 0;
+var Promise = RSVP.Promise;
+
+var EmberTest;
+var EmberTesting;
+
+QUnit.module("Deferred RSVP's async + Testing", {
+  setup: function() {
+    EmberTest = Ember.Test;
+    EmberTesting = Ember.testing;
+
+    Ember.Test = {
+      adapter: {
+        asyncStart: function() {
+          asyncStarted++;
+          QUnit.stop();
+        },
+        asyncEnd: function() {
+          asyncEnded++;
+          QUnit.start();
+        }
+      }
+    };
+  },
+  teardown: function() {
+    asyncStarted = 0;
+    asyncEnded = 0;
+
+    Ember.testing = EmberTesting;
+    Ember.Test =  EmberTest;
+  }
+});
+
+test("given `Ember.testing = true`, correctly informs the test suite about async steps", function() {
+  expect(19);
+
+  ok(!run.currentRunLoop, 'expect no run-loop');
+
+  Ember.testing = true;
+
+  equal(asyncStarted, 0);
+  equal(asyncEnded, 0);
+
+  var user = Promise.resolve({
+    name: 'tomster'
+  });
+
+  equal(asyncStarted, 0);
+  equal(asyncEnded, 0);
+
+  user.then(function(user){
+    equal(asyncStarted, 1);
+    equal(asyncEnded, 1);
+
+    equal(user.name, 'tomster');
+
+    return Promise.resolve(1).then(function(){
+      equal(asyncStarted, 1);
+      equal(asyncEnded, 1);
+    });
+
+  }).then(function(){
+    equal(asyncStarted, 1);
+    equal(asyncEnded, 1);
+
+    return new Promise(function(resolve){
+      QUnit.stop(); // raw async, we must inform the test framework manually
+      setTimeout(function(){
+        QUnit.start(); // raw async, we must inform the test framework manually
+
+        equal(asyncStarted, 1);
+        equal(asyncEnded, 1);
+
+        resolve({
+          name: 'async tomster'
+        });
+
+        equal(asyncStarted, 2);
+        equal(asyncEnded, 1);
+      }, 0);
+    });
+  }).then(function(user){
+    equal(user.name, 'async tomster');
+    equal(asyncStarted, 2);
+    equal(asyncEnded, 2);
+  });
+});