Convert ember-testing and @ember/test to TS

packages/@ember/-internals/error-handling/index.ts

@@ -14,12 +14,12 @@ export function setOnerror(handler: Function) {
   onerror = handler;
 }
 
-let dispatchOverride: Function | undefined;
+let dispatchOverride: Function | null = null;
 
 // allows testing adapter to override dispatch
 export function getDispatchOverride() {
   return dispatchOverride;
 }
-export function setDispatchOverride(handler: Function) {
+export function setDispatchOverride(handler: Function | null) {
   dispatchOverride = handler;
 }

packages/@ember/application/lib/application.ts

@@ -23,7 +23,7 @@ import {
 } from '@ember/-internals/routing';
 import type { BootOptions } from '../instance';
 import ApplicationInstance from '../instance';
-import Engine from '@ember/engine';
+import Engine, { buildInitializerMethod } from '@ember/engine';
 import type { Container, Registry } from '@ember/-internals/container';
 import { privatize as P } from '@ember/-internals/container';
 import { setupApplicationRegistry } from '@ember/-internals/glimmer';
@@ -220,6 +220,16 @@ class Application extends Engine {
     return registry;
   }
 
+  static initializer = buildInitializerMethod<'initializers', Application>(
+    'initializers',
+    'initializer'
+  );
+
+  static instanceInitializer = buildInitializerMethod<'instanceInitializers', ApplicationInstance>(
+    'instanceInitializers',
+    'instance initializer'
+  );
+
   /**
     The root DOM element of the Application. This can be specified as an
     element or a [selector string](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors#reference_table_of_selectors).

packages/@ember/application/lib/lazy_load.ts

@@ -33,7 +33,7 @@ export let _loaded = loaded;
   @param callback {Function} callback to be called
   @private
 */
-export function onLoad(name: string, callback: (obj: unknown) => void) {
+export function onLoad(name: string, callback: (obj: any) => void) {
   let object = loaded[name];
 
   let hooks = (loadHooks[name] ??= []);

packages/@ember/debug/index.ts

@@ -30,7 +30,7 @@ export type AssertFunc = (desc: string, condition?: unknown) => asserts conditio
 export type DebugFunc = (message: string) => void;
 export type DebugSealFunc = (obj: object) => void;
 export type DebugFreezeFunc = (obj: object) => void;
-export type InfoFunc = (message: string, options: object) => void;
+export type InfoFunc = (message: string, options?: object) => void;
 export type RunInDebugFunc = (func: () => void) => void;
 export type DeprecateFuncFunc = (
   message: string,

packages/@ember/engine/index.ts

@@ -467,7 +467,8 @@ function resolverFor(namespace: Engine) {
   return ResolverClass.create(props);
 }
 
-function buildInitializerMethod<
+/** @internal */
+export function buildInitializerMethod<
   B extends 'initializers' | 'instanceInitializers',
   T extends B extends 'initializers' ? Engine : EngineInstance
 >(bucketName: B, humanName: string) {

packages/@ember/test/adapter.ts

@@ -0,0 +1,3 @@
+import { Adapter } from 'ember-testing';
+
+export default Adapter;

packages/@ember/test/index.js → packages/@ember/test/index.ts

@@ -1,10 +1,11 @@
 import require, { has } from 'require';
+import { type Test } from 'ember-testing';
 
-export let registerAsyncHelper;
-export let registerHelper;
-export let registerWaiter;
-export let unregisterHelper;
-export let unregisterWaiter;
+export let registerAsyncHelper: typeof Test['registerAsyncHelper'] | (() => never);
+export let registerHelper: typeof Test['registerHelper'] | (() => never);
+export let registerWaiter: typeof Test['registerWaiter'] | (() => never);
+export let unregisterHelper: typeof Test['unregisterHelper'] | (() => never);
+export let unregisterWaiter: typeof Test['unregisterWaiter'] | (() => never);
 
 if (has('ember-testing')) {
   let { Test } = require('ember-testing');

packages/ember-testing/lib/adapters/adapter.js → packages/ember-testing/lib/adapters/adapter.ts

@@ -11,7 +11,12 @@ import { Object as EmberObject } from '@ember/-internals/runtime';
   @class TestAdapter
   @public
 */
-export default EmberObject.extend({
+interface Adapter extends EmberObject {
+  asyncStart(): void;
+  asyncEnd(): void;
+  exception(error: unknown): never;
+}
+const Adapter = EmberObject.extend({
   /**
     This callback will be called whenever an async operation is about to start.
 
@@ -48,7 +53,9 @@ export default EmberObject.extend({
     @method exception
     @param {String} error The exception to be raised.
   */
-  exception(error) {
+  exception(error: unknown) {
     throw error;
   },
 });
+
+export default Adapter;

packages/ember-testing/lib/adapters/qunit.js → packages/ember-testing/lib/adapters/qunit.ts

@@ -2,6 +2,15 @@
 
 import { inspect } from '@ember/-internals/utils';
 import Adapter from './adapter';
+
+interface VeryOldQunit {
+  stop(): void;
+}
+
+function isVeryOldQunit(obj: unknown): obj is VeryOldQunit {
+  return obj != null && typeof (obj as VeryOldQunit).stop === 'function';
+}
+
 /**
    @module ember
 */
@@ -14,25 +23,28 @@ import Adapter from './adapter';
   @extends TestAdapter
   @public
 */
-export default Adapter.extend({
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface QUnitAdapter extends Adapter {}
+const QUnitAdapter = Adapter.extend({
   init() {
     this.doneCallbacks = [];
   },
 
   asyncStart() {
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       // very old QUnit version
       // eslint-disable-next-line qunit/no-qunit-stop
       QUnit.stop();
     } else {
       this.doneCallbacks.push(QUnit.config.current ? QUnit.config.current.assert.async() : null);
     }
   },
+
   asyncEnd() {
     // checking for QUnit.stop here (even though we _need_ QUnit.start) because
     // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
     // inside a test context)
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       QUnit.start();
     } else {
       let done = this.doneCallbacks.pop();
@@ -42,7 +54,10 @@ export default Adapter.extend({
       }
     }
   },
-  exception(error) {
+
+  exception(error: unknown) {
     QUnit.config.current.assert.ok(false, inspect(error));
   },
 });
+
+export default QUnitAdapter;

packages/ember-testing/lib/ext/application.js → packages/ember-testing/lib/ext/application.ts

@@ -5,6 +5,19 @@ import TestPromise, { resolve, getLastPromise } from '../test/promise';
 import run from '../test/run';
 import { invokeInjectHelpersCallbacks } from '../test/on_inject_helpers';
 import { asyncStart, asyncEnd } from '../test/adapter';
+import type Application from '@ember/application';
+import type { AnyFn } from '@ember/-internals/utils/types';
+import { assert } from '@ember/debug';
+
+export interface TestableApp extends Application {
+  testing?: boolean;
+  testHelpers: Record<string, (...args: unknown[]) => unknown>;
+  originalMethods: Record<string, (...args: unknown[]) => unknown>;
+  setupForTesting(): void;
+  helperContainer: object | null;
+  injectTestHelpers(helperContainer: unknown): void;
+  removeTestHelpers(): void;
+}
 
 EmberApplication.reopen({
   /**
@@ -105,25 +118,28 @@ EmberApplication.reopen({
     @method injectTestHelpers
     @public
   */
-  injectTestHelpers(helperContainer) {
+  injectTestHelpers(this: TestableApp, helperContainer: object) {
     if (helperContainer) {
       this.helperContainer = helperContainer;
     } else {
       this.helperContainer = window;
     }
 
     this.reopen({
-      willDestroy() {
+      willDestroy(this: TestableApp) {
         this._super(...arguments);
         this.removeTestHelpers();
       },
     });
 
     this.testHelpers = {};
     for (let name in helpers) {
-      this.originalMethods[name] = this.helperContainer[name];
-      this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
-      protoWrap(TestPromise.prototype, name, helper(this, name), helpers[name].meta.wait);
+      // SAFETY: It is safe to access a property on an object
+      this.originalMethods[name] = (this.helperContainer as any)[name];
+      // SAFETY: It is not quite as safe to do this, but it _seems_ to be ok.
+      this.testHelpers[name] = (this.helperContainer as any)[name] = helper(this, name);
+      // SAFETY: We checked that it exists
+      protoWrap(TestPromise.prototype, name, helper(this, name), helpers[name]!.meta.wait);
     }
 
     invokeInjectHelpersCallbacks(this);
@@ -149,7 +165,8 @@ EmberApplication.reopen({
 
     for (let name in helpers) {
       this.helperContainer[name] = this.originalMethods[name];
-      delete TestPromise.prototype[name];
+      // SAFETY: This is a weird thing, but it's not technically unsafe here.
+      delete (TestPromise.prototype as any)[name];
       delete this.testHelpers[name];
       delete this.originalMethods[name];
     }
@@ -159,26 +176,30 @@ EmberApplication.reopen({
 // This method is no longer needed
 // But still here for backwards compatibility
 // of helper chaining
-function protoWrap(proto, name, callback, isAsync) {
-  proto[name] = function (...args) {
+function protoWrap(proto: TestPromise<unknown>, name: string, callback: AnyFn, isAsync: boolean) {
+  // SAFETY: This isn't entirely safe, but it _seems_ to be ok.
+  (proto as any)[name] = function (...args: unknown[]) {
     if (isAsync) {
       return callback.apply(this, args);
     } else {
-      return this.then(function () {
+      // SAFETY: This is not actually safe.
+      return (this as any).then(function (this: any) {
         return callback.apply(this, args);
       });
     }
   };
 }
 
-function helper(app, name) {
-  let fn = helpers[name].method;
-  let meta = helpers[name].meta;
+function helper(app: TestableApp, name: string) {
+  let helper = helpers[name];
+  assert(`[BUG] Missing helper: ${name}`, helper);
+  let fn = helper.method;
+  let meta = helper.meta;
   if (!meta.wait) {
-    return (...args) => fn.apply(app, [app, ...args]);
+    return (...args: unknown[]) => fn.apply(app, [app, ...args]);
   }
 
-  return (...args) => {
+  return (...args: unknown[]) => {
     let lastPromise = run(() => resolve(getLastPromise()));
 
     // wait for last helper's promise to resolve and then

packages/ember-testing/lib/ext/rsvp.ts

@@ -0,0 +1,22 @@
+import { RSVP } from '@ember/-internals/runtime';
+import { _backburner } from '@ember/runloop';
+import { isTesting } from '@ember/debug';
+import { asyncStart, asyncEnd } from '../test/adapter';
+
+RSVP.configure(
+  'async',
+  function (callback: (promise: Promise<unknown>) => void, promise: Promise<unknown>) {
+    // if schedule will cause autorun, we need to inform adapter
+    if (isTesting() && !_backburner.currentInstance) {
+      asyncStart();
+      _backburner.schedule('actions', () => {
+        asyncEnd();
+        callback(promise);
+      });
+    } else {
+      _backburner.schedule('actions', () => callback(promise));
+    }
+  }
+);
+
+export default RSVP;

packages/ember-testing/lib/helpers/and_then.ts

@@ -0,0 +1,8 @@
+import { assert } from '@ember/debug';
+import type { TestableApp } from '../ext/application';
+
+export default function andThen(app: TestableApp, callback: (app: TestableApp) => unknown) {
+  let wait = app.testHelpers['wait'];
+  assert('[BUG] Missing wait helper', wait);
+  return wait(callback(app));
+}

packages/ember-testing/lib/helpers/current_path.js → packages/ember-testing/lib/helpers/current_path.ts

@@ -2,6 +2,9 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import type Application from '@ember/application';
+import { assert } from '@ember/debug';
 
 /**
   Returns the current path.
@@ -21,7 +24,14 @@ click('#some-link-id').then(validateURL);
 @since 1.5.0
 @public
 */
-export default function currentPath(app) {
+export default function currentPath(app: Application) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
+  assert(
+    '[BUG] service:-routing is not a RoutingService',
+    routingService instanceof RoutingService
+  );
+
   return get(routingService, 'currentPath');
 }

packages/ember-testing/lib/helpers/current_route_name.js → packages/ember-testing/lib/helpers/current_route_name.ts

@@ -2,6 +2,9 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import type Application from '@ember/application';
+import { assert } from '@ember/debug';
 /**
   Returns the currently active route name.
 
@@ -19,7 +22,14 @@ visit('/some/path').then(validateRouteName)
 @since 1.5.0
 @public
 */
-export default function currentRouteName(app) {
+export default function currentRouteName(app: Application) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
+  assert(
+    '[BUG] service:-routing is not a RoutingService',
+    routingService instanceof RoutingService
+  );
+
   return get(routingService, 'currentRouteName');
 }