Merge pull request #498 from rwjblue/add-settled-opt-out

Add ability to opt-out of automatic settledness waiting in teardown.

addon-test-support/@ember/test-helpers/teardown-application-context.ts

@@ -1,12 +1,24 @@
+import { nextTickPromise } from './-utils';
 import settled from './settled';
 
 /**
   Used by test framework addons to tear down the provided context after testing is completed.
 
   @public
   @param {Object} context the context to setup
+  @param {Object} [options] options used to override defaults
+  @param {boolean} [options.waitForSettled=true] should the teardown wait for `settled()`ness
   @returns {Promise<void>} resolves when settled
 */
-export default function(context: object): Promise<void> {
-  return settled();
+export default function(context: object, options?: { waitForSettled?: boolean }): Promise<void> {
+  let waitForSettled = true;
+  if (options !== undefined && 'waitForSettled' in options) {
+    waitForSettled = options.waitForSettled!;
+  }
+
+  if (waitForSettled) {
+    return settled();
+  }
+
+  return nextTickPromise();
 }

addon-test-support/@ember/test-helpers/teardown-context.ts

@@ -17,9 +17,18 @@ import Ember from 'ember';
 
   @public
   @param {Object} context the context to setup
+  @param {Object} [options] options used to override defaults
+  @param {boolean} [options.waitForSettled=true] should the teardown wait for `settled()`ness
   @returns {Promise<void>} resolves when settled
 */
-export default function teardownContext(context: TestContext): Promise<void> {
+export default function teardownContext(
+  context: TestContext,
+  options?: { waitForSettled?: boolean }
+): Promise<void> {
+  let waitForSettled = true;
+  if (options !== undefined && 'waitForSettled' in options) {
+    waitForSettled = options.waitForSettled!;
+  }
   return nextTickPromise()
     .then(() => {
       let { owner } = context;
@@ -31,13 +40,21 @@ export default function teardownContext(context: TestContext): Promise<void> {
 
       unsetContext();
 
-      return settled();
+      if (waitForSettled) {
+        return settled();
+      }
+
+      return nextTickPromise();
     })
     .finally(() => {
       let contextGuid = guidFor(context);
 
       runDestroyablesFor(CLEANUP, contextGuid);
 
-      return settled();
+      if (waitForSettled) {
+        return settled();
+      }
+
+      return nextTickPromise();
     });
 }

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

@@ -13,14 +13,28 @@ import settled from './settled';
 
   @public
   @param {Object} context the context to setup
+  @param {Object} [options] options used to override defaults
+  @param {boolean} [options.waitForSettled=true] should the teardown wait for `settled()`ness
   @returns {Promise<void>} resolves when settled
 */
-export default function teardownRenderingContext(context: RenderingTestContext): Promise<void> {
+export default function teardownRenderingContext(
+  context: RenderingTestContext,
+  options?: { waitForSettled?: boolean }
+): Promise<void> {
+  let waitForSettled = true;
+  if (options !== undefined && 'waitForSettled' in options) {
+    waitForSettled = options.waitForSettled!;
+  }
+
   return nextTickPromise().then(() => {
     let contextGuid = guidFor(context);
 
     runDestroyablesFor(RENDERING_CLEANUP, contextGuid);
 
-    return settled();
+    if (waitForSettled) {
+      return settled();
+    }
+
+    return nextTickPromise();
   });
 }

tests/helpers/manual-test-waiter.js

@@ -0,0 +1,13 @@
+import { registerWaiter, unregisterWaiter } from '@ember/test';
+
+export default function setupManualTestWaiter(hooks) {
+  hooks.beforeEach(function() {
+    this.shouldWait = false;
+    this._waiter = () => !this.shouldWait;
+    registerWaiter(this._waiter);
+  });
+
+  hooks.afterEach(function() {
+    unregisterWaiter(this._waiter);
+  });
+}

tests/unit/teardown-context-test.js

@@ -1,18 +1,28 @@
 import { module, test } from 'qunit';
 import Service from '@ember/service';
-import { getContext, setupContext, teardownContext, getSettledState } from '@ember/test-helpers';
+import {
+  getContext,
+  setupContext,
+  teardownContext,
+  getSettledState,
+  settled,
+  isSettled,
+} from '@ember/test-helpers';
 import { setResolverRegistry } from '../helpers/resolver';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
 import Ember from 'ember';
 import hasjQuery from '../helpers/has-jquery';
 import ajax from '../helpers/ajax';
 import Pretender from 'pretender';
+import setupManualTestWaiter from '../helpers/manual-test-waiter';
 
 module('teardownContext', function(hooks) {
   if (!hasEmberVersion(2, 4)) {
     return;
   }
 
+  setupManualTestWaiter(hooks);
+
   let context;
   hooks.beforeEach(function() {
     this.pretender = new Pretender();
@@ -69,4 +79,19 @@ module('teardownContext', function(hooks) {
       assert.equal(state.pendingRequestCount, 0, 'pendingRequestCount is 0');
     });
   }
+
+  test('can opt out of waiting for settledness', async function(assert) {
+    this.shouldWait = true;
+
+    assert.equal(isSettled(), false, 'should not be settled');
+
+    await teardownContext(context, { waitForSettled: false });
+
+    assert.equal(isSettled(), false, 'should not be settled');
+
+    this.shouldWait = false;
+    await settled();
+
+    assert.equal(isSettled(), true, 'should be settled');
+  });
 });

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

@@ -4,13 +4,17 @@ import {
   setupRenderingContext,
   teardownContext,
   teardownRenderingContext,
+  settled,
+  isSettled,
 } from '@ember/test-helpers';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
+import setupManualTestWaiter from '../helpers/manual-test-waiter';
 
 module('teardownRenderingContext', function(hooks) {
   if (!hasEmberVersion(2, 4)) {
     return;
   }
+  setupManualTestWaiter(hooks);
 
   hooks.beforeEach(async function() {
     await setupContext(this);
@@ -54,4 +58,20 @@ module('teardownRenderingContext', function(hooks) {
       'previous ember-testing element is no longer in DOM'
     );
   });
+
+  test('can opt out of waiting for settledness', async function(assert) {
+    this.shouldWait = true;
+
+    assert.equal(isSettled(), false, 'should not be settled');
+
+    await teardownRenderingContext(this, { waitForSettled: false });
+    await teardownContext(this, { waitForSettled: false });
+
+    assert.equal(isSettled(), false, 'should not be settled');
+
+    this.shouldWait = false;
+    await settled();
+
+    assert.equal(isSettled(), true, 'should be settled');
+  });
 });