Resolve deprecations from tests

Author: NullVoxPopuli

test-app/tests/helpers/module-for-acceptance.js

@@ -1,15 +1,16 @@
 import { resolve } from 'rsvp';
+import { setTesting } from '@ember/debug';
 import { module } from 'qunit';
 import startApp from '../helpers/start-app';
 import destroyApp from '../helpers/destroy-app';
 import { setResolverRegistry } from './resolver';
 import QUnitTestAdapter from './qunit-test-adapter';
-import Ember from 'ember';
+import { setAdapter } from 'ember-testing/lib/setup_for_testing';
 
 export default function (name, options = {}) {
   module(name, {
     beforeEach() {
-      Ember.Test.adapter = QUnitTestAdapter.create();
+      setAdapter(QUnitTestAdapter.create());
 
       if (options.registry) {
         setResolverRegistry(options.registry);
@@ -20,7 +21,7 @@ export default function (name, options = {}) {
       );
       this.fixtureResetValue = testElementContainer.innerHTML;
 
-      Ember.testing = true;
+      setTesting(true);
       this.application = startApp();
 
       if (options.beforeEach) {
@@ -34,7 +35,7 @@ export default function (name, options = {}) {
       return resolve(afterEach)
         .then(() => destroyApp(this.application))
         .finally(() => {
-          Ember.testing = false;
+          setTesting(false);
 
           document.getElementById('ember-testing-container').innerHTML =
             this.fixtureResetValue;

test-app/tests/helpers/qunit-module-for.js

@@ -1,17 +1,18 @@
-import Ember from 'ember';
+import { isTesting } from '@ember/debug';
 import { module } from 'qunit';
 import QUnitTestAdapter from './qunit-test-adapter';
+import { setAdapter } from 'ember-testing/lib/setup_for_testing';
 
 export default function qunitModuleFor(testModule) {
   module(testModule.name, {
     beforeEach(assert) {
-      if (Ember.testing) {
+      if (isTesting()) {
         throw new Error('should not have Ember.testing === true in beforeEach');
       }
-      Ember.Test.adapter = QUnitTestAdapter.create();
+      setAdapter(QUnitTestAdapter.create());
       testModule.setContext(this);
       return testModule.setup(assert).finally(() => {
-        if (!Ember.testing) {
+        if (!isTesting()) {
           throw new Error(
             'should have Ember.testing === true after tests have started'
           );
@@ -20,8 +21,8 @@ export default function qunitModuleFor(testModule) {
     },
     afterEach(assert) {
       return testModule.teardown(assert).finally(() => {
-        Ember.Test.adapter = null;
-        if (Ember.testing) {
+        setAdapter(null);
+        if (isTesting()) {
           throw new Error(
             'should not have Ember.testing === true after tests have finished'
           );

test-app/tests/helpers/qunit-test-adapter.js

@@ -1,5 +1,5 @@
-import Ember from 'ember';
 import QUnit from 'qunit';
+import { Adapter } from '@ember/test';
 
 /*
  * This module is inlined here, because this library cannot depend on
@@ -30,7 +30,7 @@ function unhandledRejectionAssertion(current, error) {
   });
 }
 
-export default Ember.Test.Adapter.extend({
+export default Adapter.extend({
   init() {
     this.doneCallbacks = [];
   },

test-app/tests/integration/setup-rendering-context-test.js

@@ -1,9 +1,8 @@
-import Ember from 'ember';
 import { module, test } from 'qunit';
 import Component, { setComponentTemplate } from '@ember/component';
 import GlimmerComponent from '@glimmer/component';
 import { helper } from '@ember/component/helper';
-import { registerWaiter } from '@ember/test';
+import { unregisterWaiter, registerWaiter } from '@ember/test';
 import {
   setupContext,
   setupRenderingContext,
@@ -87,7 +86,7 @@ module('setupRenderingContext "real world"', function (hooks) {
   });
 
   hooks.afterEach(async function () {
-    Ember.Test.unregisterWaiter(this._waiter);
+    unregisterWaiter(this._waiter);
     await teardownContext(this);
   });
 

test-app/tests/test-helper.js

@@ -1,5 +1,6 @@
 import * as QUnit from 'qunit';
-import Ember from 'ember';
+
+import { isTesting, setTesting } from '@ember/debug';
 import { isSettled, getSettledState } from '@ember/test-helpers';
 import { _backburner } from '@ember/runloop';
 import './helpers/resolver';
@@ -49,13 +50,13 @@ QUnit.testDone(function ({ module, name }) {
   }
 
   // this is used to ensure that no tests accidentally leak `Ember.testing` state
-  if (Ember.testing) {
-    let message = `Ember.testing should be reset after test has completed. ${module}: ${name} did not reset Ember.testing`;
+  if (isTesting()) {
+    let message = `isTesting() should be reset after test has completed. ${module}: ${name} did not reset isTesting()`;
     cleanupFailures.push(message);
 
     // eslint-disable-next-line
     console.error(message);
-    Ember.testing = false;
+    setTesting(false);
   }
 
   if (!isSettled()) {

test-app/tests/unit/settled-test.js

@@ -1,4 +1,4 @@
-import Ember from 'ember';
+import { registerWaiter, unregisterWaiter } from '@ember/test';
 import { module, test } from 'qunit';
 import { isSettled, getSettledState } from '@ember/test-helpers';
 import { macroCondition, dependencySatisfies } from '@embroider/macros';
@@ -69,20 +69,13 @@ module('settled', function (hooks) {
       return !this.isWaiterPending;
     };
 
-    // In Ember < 2.8 `registerWaiter` expected to be bound to
-    // `Ember.Test` 😭
-    //
-    // Once we have dropped support for < 2.8 we should swap this to
-    // use:
-    //
-    // import { registerWaiter } from '@ember/test';
-    Ember.Test.registerWaiter(this._legacyWaiter);
+    registerWaiter(this._legacyWaiter);
 
     this._testWaiter = buildWaiter(WAITER_NAME);
   });
 
   hooks.afterEach(function () {
-    Ember.Test.unregisterWaiter(this._legacyWaiter);
+    unregisterWaiter(this._legacyWaiter);
     resetWaiters();
     this.server.shutdown();
     _teardownAJAXHooks();

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

@@ -1,4 +1,5 @@
 import { module, test } from 'qunit';
+import { isTesting } from '@ember/debug';
 import Service, { inject as injectService } from '@ember/service';
 import {
   setupContext,
@@ -26,7 +27,6 @@ import {
 } from '../helpers/resolver';
 import App from '../../app';
 import config from '../../config/environment';
-import Ember from 'ember';
 import { deprecate, warn } from '@ember/debug';
 
 module('setupContext', function (hooks) {
@@ -822,20 +822,17 @@ module('setupContext', function (hooks) {
       });
     });
 
-    test('Ember.testing', async function (assert) {
-      assert.notOk(
-        Ember.testing,
-        'precond - Ember.testing is falsey before setup'
-      );
+    test('isTesting()', async function (assert) {
+      assert.notOk(isTesting(), 'precond - isTesting() is falsey before setup');
 
       context = {};
       let promise = setupContext(context);
 
-      assert.ok(Ember.testing, 'Ember.testing is truthy sync after setup');
+      assert.ok(isTesting(), 'isTesting() is truthy sync after setup');
 
       await promise;
 
-      assert.ok(Ember.testing, 'Ember.testing is truthy async after setup');
+      assert.ok(isTesting(), 'isTesting() is truthy async after setup');
     });
   }
 

test-app/tests/unit/setup-ember-onerror-test.js

@@ -1,5 +1,5 @@
-import Ember from 'ember';
 import { module, test } from 'qunit';
+import { getOnerror } from '@ember/-internals/error-handling';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
 import { setupContext, teardownContext } from '@ember/test-helpers';
 import { setupOnerror, resetOnerror } from '@ember/test-helpers';
@@ -23,38 +23,38 @@ module('setupOnerror', function (hooks) {
         await setupContext(context);
       });
 
-      test('Ember.onerror is undefined by default', function (assert) {
+      test('onerror is undefined by default', function (assert) {
         assert.expect(1);
 
-        assert.equal(Ember.onerror, undefined);
+        assert.equal(getOnerror(), undefined);
       });
 
-      test('Ember.onerror is setup correctly', async function (assert) {
+      test('onerror is setup correctly', async function (assert) {
         assert.expect(2);
 
         let onerror = (err) => err;
 
-        assert.equal(Ember.onerror, undefined);
+        assert.equal(getOnerror(), undefined);
 
         setupOnerror(onerror);
 
-        assert.equal(Ember.onerror, onerror);
+        assert.equal(getOnerror(), onerror);
       });
 
-      test('Ember.onerror is reset correctly', async function (assert) {
+      test('onerror is reset correctly', async function (assert) {
         assert.expect(3);
 
         let onerror = (err) => err;
 
-        assert.equal(Ember.onerror, undefined);
+        assert.equal(getOnerror(), undefined);
 
         setupOnerror(onerror);
 
-        assert.equal(Ember.onerror, onerror);
+        assert.equal(getOnerror(), onerror);
 
         resetOnerror();
 
-        assert.equal(Ember.onerror, undefined);
+        assert.equal(getOnerror(), undefined);
       });
     });
 

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

@@ -10,7 +10,8 @@ import {
 } from '@ember/test-helpers';
 import { setResolverRegistry } from '../helpers/resolver';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
-import Ember from 'ember';
+import { isTesting } from '@ember/debug';
+
 import hasjQuery from '../helpers/has-jquery';
 import ajax from '../helpers/ajax';
 import Pretender from 'pretender';
@@ -48,12 +49,12 @@ module('teardownContext', function (hooks) {
     assert.ok(instance.isDestroying, 'destroying');
   });
 
-  test('it sets Ember.testing to false', async function (assert) {
-    assert.ok(Ember.testing, 'precond - Ember.testing is truthy');
+  test('it sets isTesting() to false', async function (assert) {
+    assert.ok(isTesting(), 'precond - isTesting() is truthy');
 
     await teardownContext(context);
 
-    assert.notOk(Ember.testing, 'Ember.testing is falsey after teardown');
+    assert.notOk(isTesting(), 'isTesting() is falsey after teardown');
   });
 
   test('it unsets the context', async function (assert) {

test-app/tests/unit/validate-error-handler-test.js

@@ -1,5 +1,5 @@
+import { getOnerror, setOnerror } from '@ember/-internals/error-handling';
 import { module, test } from 'qunit';
-import Ember from 'ember';
 
 import { validateErrorHandler } from '@ember/test-helpers';
 
@@ -52,41 +52,41 @@ module('validateErrorHandler', function (hooks) {
 
   module('without a passed in callback', function (hooks) {
     hooks.beforeEach(function () {
-      this.originalOnerror = Ember.onerror;
+      this.originalOnerror = getOnerror();
     });
 
     hooks.afterEach(function () {
-      Ember.onerror = this.originalOnerror;
+      setOnerror(this.originalOnerror);
     });
 
     test('invokes the provided callback', function (assert) {
       assert.expect(1);
 
-      Ember.onerror = function () {
+      setOnerror(function () {
         assert.ok(true, 'error handler was invoked');
-      };
+      });
 
       validateErrorHandler();
     });
 
     test('considers handler missing to be a valid handler', function (assert) {
-      Ember.onerror = undefined;
+      setOnerror(undefined);
       let result = validateErrorHandler();
 
       assert.valid(result);
     });
 
     test('when the provided function does _not_ rethrow it is invalid', function (assert) {
-      Ember.onerror = function () {};
+      setOnerror(function () {});
       let result = validateErrorHandler();
 
       assert.invalid(result);
     });
 
     test('when the provided function does rethrow it is valid', function (assert) {
-      Ember.onerror = function (error) {
+      setOnerror(function (error) {
         throw error;
-      };
+      });
 
       let result = validateErrorHandler();