Adding tests not settled detection support in tests

addon-test-support/ember-qunit/async-timer-leak-detection.js

@@ -0,0 +1,23 @@
+export function detectPendingTimers(
+  hasPendingTimers,
+  pendingTimers,
+  testModule,
+  testName,
+  cancelTimers
+) {
+  if (hasPendingTimers) {
+    pendingTimers.push(`${testModule}: ${testName}`);
+    cancelTimers();
+  }
+}
+
+export function reportPendingTimers(pendingTimers) {
+  if (pendingTimers.length > 0) {
+    throw new Error(
+      `ASYNC LEAKAGE DETECTED IN TESTS
+       The following (${pendingTimers.length}) tests setup a timer that was never torn down before the test completed: \n
+       ${pendingTimers.join('\n')}
+      `
+    );
+  }
+}

addon-test-support/ember-qunit/index.js

@@ -6,6 +6,7 @@ export { module, test, skip, only, todo } from 'qunit';
 export { loadTests } from './test-loader';
 
 import { deprecate } from '@ember/debug';
+import { run } from '@ember/runloop';
 import { loadTests } from './test-loader';
 import Ember from 'ember';
 import QUnit from 'qunit';
@@ -24,7 +25,11 @@ import {
   setupApplicationContext,
   teardownApplicationContext,
   validateErrorHandler,
+  getSettledState,
 } from '@ember/test-helpers';
+import { detectPendingTimers, reportPendingTimers } from './async-timer-leak-detection';
+
+const TESTS_WITH_LEAKY_ASYNC = [];
 
 export function setResolver() {
   deprecate(
@@ -228,6 +233,18 @@ export function setupEmberOnerrorValidation() {
   });
 }
 
+export function setupAsyncTimerLeakDetection() {
+  QUnit.testDone(({ module, name }) => {
+    let { hasPendingTimers } = getSettledState();
+
+    detectPendingTimers(hasPendingTimers, TESTS_WITH_LEAKY_ASYNC, module, name, run.cancelTimers);
+  });
+
+  QUnit.done(() => {
+    reportPendingTimers(TESTS_WITH_LEAKY_ASYNC);
+  });
+}
+
 /**
    @method start
    @param {Object} [options] Options to be used for enabling/disabling behaviors
@@ -265,6 +282,10 @@ export function start(options = {}) {
     setupEmberOnerrorValidation();
   }
 
+  if (options.setupAsyncTimerLeakDetection !== false) {
+    setupAsyncTimerLeakDetection();
+  }
+
   if (options.startTests !== false) {
     startTests();
   }

testem.js

@@ -9,12 +9,15 @@ module.exports = {
     'Chrome'
   ],
   browser_args: {
-    Chrome: [
-      '--disable-gpu',
-      '--headless',
-      '--no-sandbox',
-      '--remote-debugging-port=9222',
-      '--window-size=1440,900'
-    ]
+    Chrome: {
+      mode: 'ci',
+      args: [
+        '--disable-gpu',
+        '--headless',
+        '--no-sandbox',
+        '--remote-debugging-port=9222',
+        '--window-size=1440,900'
+      ]
+    }
   }
 };

tests/unit/setup-async-timer-leak-detection-test.js

@@ -0,0 +1,65 @@
+import { module, test } from 'qunit';
+import { detectPendingTimers, reportPendingTimers } from 'ember-qunit/async-timer-leak-detection';
+
+module('setupEmberOnerrorValidation', function() {
+  test('detectPendingTimers does not queue test info when leaky async timers not detected', function(assert) {
+    assert.expect(2);
+
+    let hasPendingTimers = false;
+    let pendingTimers = [];
+    let callCount = 0;
+    let cancelTimers = () => {
+      callCount++;
+    };
+
+    detectPendingTimers(hasPendingTimers, pendingTimers, '', '', cancelTimers);
+
+    assert.equal(callCount, 0, 'cancel was not called');
+    assert.equal(pendingTimers.length, 0, 'pending timers has no pending messages');
+  });
+
+  test('detectPendingTimers correctly queues test info when leaky async timers detected', function(assert) {
+    assert.expect(3);
+
+    let hasPendingTimers = true;
+    let pendingTimers = [];
+    let callCount = 0;
+    let cancelTimers = () => {
+      callCount++;
+    };
+
+    detectPendingTimers(hasPendingTimers, pendingTimers, 'module', 'test name', cancelTimers);
+
+    assert.equal(callCount, 1, 'cancel was called');
+    assert.equal(pendingTimers.length, 1, 'pending timers has a pending message');
+    assert.equal(
+      pendingTimers[0],
+      'module: test name',
+      'pending timers contains the correct message'
+    );
+  });
+
+  test('reportPendingTimers does not throw when no pending timers exist', function(assert) {
+    assert.expect(1);
+
+    reportPendingTimers([]);
+
+    assert.ok(true);
+  });
+
+  test('reportPendingTimers throws when pending timers exist', function(assert) {
+    assert.expect(1);
+
+    let pendingTimers = [];
+    pendingTimers.push('module: test name');
+
+    assert.throws(
+      function() {
+        reportPendingTimers(pendingTimers);
+      },
+      `ASYNC LEAKAGE DETECTED IN TESTS
+      The following (1) tests setup a timer that was never torn down before the test completed: \n
+      module: test name`
+    );
+  });
+});