Lints pass now

Lints pass now

test-app/package.json

@@ -30,6 +30,7 @@
     "@ember/optional-features": "^2.0.0",
     "@ember/string": "^3.0.1",
     "@ember/test-helpers": "^2.9.3",
+    "@ember/test-waiters": "^3.0.2",
     "@embroider/test-setup": "^2.1.1",
     "@glimmer/component": "^1.1.2",
     "@glimmer/tracking": "^1.1.2",

test-app/tests/acceptance/basic-test.js

@@ -17,7 +17,9 @@ module('setupApplicationTest tests', function (hooks) {
     return;
   }
 
-  const Router = EmberRouter.extend({ location: 'none' });
+  class Router extends EmberRouter {
+    location = 'none';
+  }
   Router.map(function () {
     this.route('widgets');
     this.route('posts', function () {
@@ -37,86 +39,95 @@ module('setupApplicationTest tests', function (hooks) {
       'template:index': hbs`<h1>Hello World!</h1>`,
       'template:posts': hbs`<h1>Posts Page</h1>{{outlet}}`,
       'template:posts/post': hbs`<div class="post-id">{{this.model.post_id}}</div>`,
-      'route:posts/post': Route.extend({
+      'route:posts/post': class extends Route {
         model(params) {
           return params;
-        },
-      }),
+        }
+      },
     });
   });
 
   test('can render', async function (assert) {
     await visit('/');
 
-    assert.equal(currentRouteName(), 'index');
-    assert.equal(currentURL(), '/');
+    assert.strictEqual(currentRouteName(), 'index');
+    assert.strictEqual(currentURL(), '/');
 
-    assert.equal(
+    assert.strictEqual(
       this.element.querySelector('.nav').textContent,
       'posts | widgets'
     );
-    assert.equal(this.element.querySelector('h1').textContent, 'Hello World!');
+    assert.strictEqual(
+      this.element.querySelector('h1').textContent,
+      'Hello World!'
+    );
   });
 
   test('can perform a basic template rendering for nested route', async function (assert) {
     await visit('/posts/1');
 
-    assert.equal(currentRouteName(), 'posts.post');
-    assert.equal(currentURL(), '/posts/1');
+    assert.strictEqual(currentRouteName(), 'posts.post');
+    assert.strictEqual(currentURL(), '/posts/1');
 
-    assert.equal(
+    assert.strictEqual(
       this.element.querySelector('.nav').textContent,
       'posts | widgets'
     );
-    assert.equal(this.element.querySelector('.post-id').textContent, '1');
+    assert.strictEqual(this.element.querySelector('.post-id').textContent, '1');
   });
 
   test('can visit multiple times', async function (assert) {
     await visit('/posts/1');
 
-    assert.equal(currentRouteName(), 'posts.post');
-    assert.equal(currentURL(), '/posts/1');
+    assert.strictEqual(currentRouteName(), 'posts.post');
+    assert.strictEqual(currentURL(), '/posts/1');
 
-    assert.equal(
+    assert.strictEqual(
       this.element.querySelector('.nav').textContent,
       'posts | widgets'
     );
-    assert.equal(this.element.querySelector('.post-id').textContent, '1');
+    assert.strictEqual(this.element.querySelector('.post-id').textContent, '1');
 
     await visit('/');
 
-    assert.equal(currentRouteName(), 'index');
-    assert.equal(currentURL(), '/');
+    assert.strictEqual(currentRouteName(), 'index');
+    assert.strictEqual(currentURL(), '/');
 
-    assert.equal(
+    assert.strictEqual(
       this.element.querySelector('.nav').textContent,
       'posts | widgets'
     );
-    assert.equal(this.element.querySelector('h1').textContent, 'Hello World!');
+    assert.strictEqual(
+      this.element.querySelector('h1').textContent,
+      'Hello World!'
+    );
 
     await visit('/posts/2');
 
-    assert.equal(currentRouteName(), 'posts.post');
-    assert.equal(currentURL(), '/posts/2');
+    assert.strictEqual(currentRouteName(), 'posts.post');
+    assert.strictEqual(currentURL(), '/posts/2');
 
-    assert.equal(
+    assert.strictEqual(
       this.element.querySelector('.nav').textContent,
       'posts | widgets'
     );
-    assert.equal(this.element.querySelector('.post-id').textContent, '2');
+    assert.strictEqual(this.element.querySelector('.post-id').textContent, '2');
   });
 
   test('can navigate amongst routes', async function (assert) {
     await visit('/');
 
-    assert.equal(currentRouteName(), 'index');
-    assert.equal(currentURL(), '/');
+    assert.strictEqual(currentRouteName(), 'index');
+    assert.strictEqual(currentURL(), '/');
 
     await click('a[href="/posts"]');
 
-    assert.equal(currentRouteName(), 'posts.index');
-    assert.equal(currentURL(), '/posts');
+    assert.strictEqual(currentRouteName(), 'posts.index');
+    assert.strictEqual(currentURL(), '/posts');
 
-    assert.equal(this.element.querySelector('h1').textContent, 'Posts Page');
+    assert.strictEqual(
+      this.element.querySelector('h1').textContent,
+      'Posts Page'
+    );
   });
 });

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

@@ -1,3 +1,4 @@
+/* eslint-disable ember/no-classic-components */
 import { module, test } from 'qunit';
 import Component from '@ember/component';
 import { helper } from '@ember/component/helper';
@@ -16,7 +17,7 @@ module('setupRenderingTest tests', function (hooks) {
   test('can render a simple template', async function (assert) {
     await render(hbs`<p>Hello!</p>`);
 
-    assert.equal(this.element.textContent, 'Hello!');
+    assert.strictEqual(this.element.textContent, 'Hello!');
   });
 
   test('can invoke template only components', async function (assert) {
@@ -26,12 +27,16 @@ module('setupRenderingTest tests', function (hooks) {
     );
     await render(hbs`<TemplateOnly />`);
 
-    assert.equal(this.element.textContent, 'template-only component here');
+    assert.strictEqual(
+      this.element.textContent,
+      'template-only component here'
+    );
   });
 
   test('can invoke JS only components', async function (assert) {
     this.owner.register(
       'component:js-only',
+      // eslint-disable-next-line ember/no-classic-classes
       Component.extend({
         classNames: ['js-only'],
       })
@@ -53,6 +58,6 @@ module('setupRenderingTest tests', function (hooks) {
 
     await render(hbs`{{jax "max"}}`);
 
-    assert.equal(this.element.textContent, 'max-jax');
+    assert.strictEqual(this.element.textContent, 'max-jax');
   });
 });

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

@@ -1,6 +1,5 @@
 import { module, test } from 'qunit';
 import Service, { inject as injectService } from '@ember/service';
-import Component from '@ember/component';
 import { setupTest } from 'ember-qunit';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
 
@@ -14,28 +13,29 @@ module('setupTest tests', function (hooks) {
   test('can be used for unit style testing', function (assert) {
     this.owner.register(
       'service:foo',
-      Service.extend({
+      class extends Service {
         someMethod() {
           return 'hello thar!';
-        },
-      })
+        }
+      }
     );
 
     let subject = this.owner.lookup('service:foo');
 
-    assert.equal(subject.someMethod(), 'hello thar!');
+    assert.strictEqual(subject.someMethod(), 'hello thar!');
   });
 
   test('can access a shared service instance', function (assert) {
-    this.owner.register('service:bar', Service.extend());
+    this.owner.register('service:bar', class extends Service {});
     this.owner.register(
       'service:foo',
-      Service.extend({
-        bar: injectService(),
+      class extends Service {
+        @injectService bar;
+
         someMethod() {
           this.set('bar.someProp', 'derp');
-        },
-      })
+        }
+      }
     );
 
     let subject = this.owner.lookup('service:foo');
@@ -45,26 +45,6 @@ module('setupTest tests', function (hooks) {
 
     subject.someMethod();
 
-    assert.equal(bar.get('someProp'), 'derp', 'property updated');
-  });
-
-  test('can create a component instance for direct testing without a template', function (assert) {
-    this.owner.register(
-      'component:foo-bar',
-      Component.extend({
-        someMethod() {
-          return 'hello thar!';
-        },
-      })
-    );
-
-    let subject;
-    if (hasEmberVersion(2, 12)) {
-      subject = this.owner.lookup('component:foo-bar');
-    } else {
-      subject = this.owner._lookupFactory('component:foo-bar').create();
-    }
-
-    assert.equal(subject.someMethod(), 'hello thar!');
+    assert.strictEqual(bar.get('someProp'), 'derp', 'property updated');
   });
 });

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

@@ -9,6 +9,7 @@ import { Promise } from 'rsvp';
 module('QUnitAdapter');
 
 test('asyncStart waits for asyncEnd to finish a test', function (assert) {
+  assert.expect(1);
   const adapter = QUnitAdapter.create();
 
   adapter.asyncStart();
@@ -19,6 +20,7 @@ test('asyncStart waits for asyncEnd to finish a test', function (assert) {
 });
 
 test('asyncStart waits for equal numbers of asyncEnd to finish a test', function (assert) {
+  assert.expect(1);
   const adapter = QUnitAdapter.create();
 
   adapter.asyncStart();
@@ -32,6 +34,7 @@ test('asyncStart waits for equal numbers of asyncEnd to finish a test', function
 });
 
 test('asyncStart should handle skipped tests that has no assert', function (assert) {
+  assert.expect(2);
   let FakeQUnitWithoutAssert = {
     config: {
       current: {},
@@ -41,7 +44,7 @@ test('asyncStart should handle skipped tests that has no assert', function (asse
   const adapter = QUnitAdapter.create({ qunit: FakeQUnitWithoutAssert });
 
   adapter.asyncStart();
-  assert.equal(adapter.doneCallbacks.length, 1);
+  assert.strictEqual(adapter.doneCallbacks.length, 1);
   assert.deepEqual(adapter.doneCallbacks, [
     {
       test: FakeQUnitWithoutAssert.config.current,
@@ -54,6 +57,7 @@ module('QUnitAdapter - Balanced async with native Promise', function () {
   const adapter = QUnitAdapter.create();
 
   test('asyncStart invoked', function (assert) {
+    assert.expect(1);
     adapter.asyncStart();
 
     assert.ok(true);
@@ -74,6 +78,7 @@ module('QUnitAdapter - Balanced async with RSVP.Promise', function () {
   const adapter = QUnitAdapter.create();
 
   test('asyncStart invoked', function (assert) {
+    assert.expect(1);
     adapter.asyncStart();
 
     assert.ok(true);

test-app/tests/unit/test-isolation-validation-test.js

@@ -1,6 +1,6 @@
-import Ember from 'ember';
 import { later, _backburner as backburner } from '@ember/runloop';
-import { module, test } from 'qunit';
+import { registerWaiter, unregisterWaiter } from '@ember/test';
+import QUnit, { module, test } from 'qunit';
 import { installTestNotIsolatedHook } from 'ember-qunit/test-isolation-validation';
 import { getDebugInfo } from '@ember/test-helpers';
 import patchAssert from './utils/patch-assert-helper';
@@ -14,17 +14,12 @@ if (getDebugInfo()) {
       return !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(waiter);
+    // eslint-disable-next-line ember/no-legacy-test-waiters
+    registerWaiter(waiter);
 
     QUnit.on('testEnd', function () {
-      Ember.Test.unregisterWaiter(this._waiter);
+      // eslint-disable-next-line ember/no-legacy-test-waiters
+      unregisterWaiter(this._waiter);
     });
 
     hooks.beforeEach(function () {

test-app/tests/unit/unhandled-rejection-test.js

@@ -21,6 +21,7 @@ module('unhandle promise rejections', function (hooks) {
   });
 
   test('RSVP promises cause an unhandled rejection', function (assert) {
+    assert.expect(2);
     let done = assert.async();
 
     window.onerror = (message) => {
@@ -36,7 +37,7 @@ module('unhandle promise rejections', function (hooks) {
     };
 
     // ensure we do not exit this test until the assertion has happened
-    setTimeout(done, 10);
+    setTimeout(() => done(), 10);
 
     new RSVPPromise((resolve) => {
       setTimeout(resolve);
@@ -47,10 +48,11 @@ module('unhandle promise rejections', function (hooks) {
 
   if (HAS_NATIVE_PROMISE && HAS_UNHANDLED_REJECTION_HANDLER) {
     test('native promises cause an unhandled rejection', function (assert) {
+      assert.expect(1);
       let done = assert.async();
 
       // ensure we do not exit this test until the assertion has happened
-      setTimeout(done, 10);
+      setTimeout(() => done(), 10);
 
       new self.Promise((resolve) => {
         setTimeout(resolve);

yarn.lock

@@ -1065,7 +1065,7 @@
     ember-cli-htmlbars "^6.1.1"
     ember-destroyable-polyfill "^2.0.3"
 
-"@ember/test-waiters@^3.0.0":
+"@ember/test-waiters@^3.0.0", "@ember/test-waiters@^3.0.2":
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/@ember/test-waiters/-/test-waiters-3.0.2.tgz#5b950c580a1891ed1d4ee64f9c6bacf49a15ea6f"
   integrity sha512-H8Q3Xy9rlqhDKnQpwt2pzAYDouww4TZIGSI1pZJhM7mQIGufQKuB0ijzn/yugA6Z+bNdjYp1HioP8Y4hn2zazQ==