WIP

Author: stefanpenner

addon-test-support/assertions/deprecations-include.js

@@ -1,7 +1,9 @@
 import { getDeprecations } from '@ember/test-helpers';
 
 export default function deprecationsInclude(expected) {
-  const deprecations = getDeprecations().map(deprecation => deprecation.message);
+  const deprecations = getDeprecations().map(
+    (deprecation) => deprecation.message
+  );
 
   this.pushResult({
     result: deprecations.indexOf(expected) > -1,

addon-test-support/assertions/deprecations.js

@@ -5,7 +5,7 @@ export default async function deprecations(callback, expectedDeprecations) {
 
   const operation = (deprecations) => {
     this.deepEqual(
-      deprecations.map(deprecation => deprecation.message),
+      deprecations.map((deprecation) => deprecation.message),
       expectedDeprecations,
       'Expected deprecations during test.'
     );

addon-test-support/assertions/expect-deprecation.js

@@ -1,29 +1,37 @@
-import { getDeprecationsForCallback, getDeprecations } from '@ember/test-helpers';
+import {
+  getDeprecationsDuringCallback,
+  getDeprecations,
+} from '@ember/test-helpers';
 import checkMatcher from './utils/check-matcher';
 
 export default function expectDeprecation(cb, matcher) {
-  const test = deprecations => {
-    const matchedDeprecations = deprecations.filter(deprecation => {
+  const test = (deprecations, matcher) => {
+    const matchedDeprecations = deprecations.filter((deprecation) => {
       return checkMatcher(deprecation.message, matcher);
     });
 
     this.pushResult({
       result: matchedDeprecations.length !== 0,
       actual: matchedDeprecations,
       expected: null,
-      message: 'Expected deprecations during test, but no deprecations were found.'
+      message:
+        'Expected deprecations during test, but no deprecations were found.',
     });
-  }
+  };
 
   if (typeof cb !== 'function') {
-    test(getDeprecations());
+    // cb is not a callback, so we assume it is the matcher
+    test(getDeprecations(), cb);
   } else {
-    const maybeThenable = getDeprecationsForCallback(cb);
-    if (maybeThenable !== null && typeof maybeThenable === 'object' && typeof maybeThenable.then === 'function') {
-      return maybeThenable.then(test);
+    const maybeThenable = getDeprecationsDuringCallback(cb);
+    if (
+      maybeThenable !== null &&
+      typeof maybeThenable === 'object' &&
+      typeof maybeThenable.then === 'function'
+    ) {
+      return maybeThenable.then((deprecations) => test(deprecations, matcher));
     } else {
-      test(maybeThenable);
+      test(maybeThenable, matcher);
     }
   }
-
 }

addon-test-support/assertions/expect-no-deprecation.js

@@ -0,0 +1,37 @@
+import checkMatcher from './utils/check-matcher';
+import {
+  getDeprecations,
+  getDeprecationsDuringCallback,
+} from '@ember/test-helpers';
+
+export default function expectNoDeprecation(cb, matcher) {
+  const test = (deprecations, matcher) => {
+    const matchedDeprecations = deprecations.filter((deprecation) => {
+      return checkMatcher(deprecation.message, matcher);
+    });
+
+    this.pushResult({
+      result: matchedDeprecations.length === 0,
+      actual: matchedDeprecations,
+      expected: [],
+      message:
+        'Expected no deprecations during test, but deprecations were found.',
+    });
+  };
+
+  if (typeof cb !== 'function') {
+    // cb is not a callback, so we assume it is the matcher
+    test(getDeprecations(), cb);
+  } else {
+    const maybeThenable = getDeprecationsDuringCallback(cb);
+    if (
+      maybeThenable !== null &&
+      typeof maybeThenable === 'object' &&
+      typeof maybeThenable.then === 'function'
+    ) {
+      return maybeThenable.then((deprecations) => test(deprecations, matcher));
+    } else {
+      test(maybeThenable, matcher);
+    }
+  }
+}

addon-test-support/assertions/expect-no-runloop.js

@@ -1,27 +1,65 @@
-import { end, _currentRunloop, _hasScheduledTimers, _cancelTimers } from '@ember/runloop';
+import {
+  run,
+  end,
+  _getCurrentRunLoop,
+  _hasScheduledTimers,
+  _cancelTimers,
+} from '@ember/runloop';
 
+function getCurrentRunLoop() {
+  // Ember 3.24.4 does not have _getCurrentRunLoop, but does have run.currentRunLoop;
+  if ('currentRunLoop' in run) {
+    return run.currentRunLoop;
+  } else {
+    return _getCurrentRunLoop();
+  }
+}
+
+// TODO: It seems very odd to mix runloop + timers into a runloop
+// specific assertion.
+//
+// We should likely:
+//
+// * have timer specific expectations
+// * have runloop specific expectations
+// * not have either cancel timers or runloop, rather those should
+//   be the explicitly choosen by the user
 export default function expectNoRunloop() {
-  if (_currentRunLoop) {
+  if (getCurrentRunLoop()) {
     this.pushResult({
       result: false,
-      actual: run.currentRunLoop,
+      actual: getCurrentRunLoop(),
       expected: null,
-      message: 'Should not be in a run loop at end of test'
+      message: 'expected no active runloop',
     });
 
-    while (_currentRunLoop) {
+    while (getCurrentRunLoop()) {
       end();
     }
+  } else {
+    this.pushResult({
+      result: true,
+      actual: null,
+      expected: null,
+      message: 'expected no active runloop',
+    });
   }
 
   if (_hasScheduledTimers()) {
     this.pushResult({
       result: false,
       actual: true,
       expected: false,
-      message: 'Ember run should not have scheduled timers at end of test'
+      message: 'expected no active timers',
     });
 
     _cancelTimers();
+  } else {
+    this.pushResult({
+      result: true,
+      actual: false,
+      expected: false,
+      message: 'expected no active timers',
+    });
   }
 }

addon-test-support/assertions/expect-no-warning.js

@@ -0,0 +1,15 @@
+import { getWarnings, getWarningsDuringCallback } from '@ember/test-helpers';
+
+export default function expectNoWarning(callback) {
+  const warnings =
+    typeof callback === 'function'
+      ? getWarningsDuringCallback(callback)
+      : getWarnings();
+
+  this.pushResult({
+    result: warnings.length === 0,
+    actual: warnings,
+    expected: [],
+    message: 'Expected no warnings during test, but warnings were found.',
+  });
+}

addon-test-support/assertions/expect-no-warnings.js

@@ -1,7 +1,7 @@
 import checkMatcher from './utils/check-matcher';
-import { getWarningsDuringCallback } from '@ember/test-helpers';
+import { getWarningsDuringCallback, getWarnings } from '@ember/test-helpers';
 
-export default function expectWarnings(callback, matcher) {
+export default function expectWarning(callback, matcher) {
   let warnings;
   if (typeof callback === 'function') {
     warnings = getWarningsDuringCallback(callback);
@@ -10,12 +10,15 @@ export default function expectWarnings(callback, matcher) {
     warnings = getWarnings();
   }
 
-  const matchedWarnings = warnings.filter(warning => checkMatcher(warning.message, matcher);
+  const actual = warnings.filter((warning) =>
+    checkMatcher(warning.message, matcher)
+  );
 
+  const result = actual.length !== 0;
   this.pushResult({
-    result: matchedWarnings.length !== 0,
-    actual: matchedWarnings,
+    result,
+    actual,
     expected: null,
-    message: 'Expected warnings during test, but no warnings were found.'
+    message: 'Expected warnings during test, but no warnings were found.',
   });
 }

…st-support/assertions/expect-warnings.js …est-support/assertions/expect-warning.jsaddon-test-support/assertions/expect-warnings.js renamed to addon-test-support/assertions/expect-warning.js addon-test-support/assertions/expect-warnings.js renamed to addon-test-support/assertions/expect-warning.js

@@ -1,10 +1,19 @@
-export function checkMatcher(message, matcher) {
+function includes(message, search) {
+  return message.includes
+    ? message.includes(search)
+    : message.indexOf(search) !== -1;
+}
+
+// TODO: test
+export default function checkMatcher(message, matcher) {
   if (typeof matcher === 'string') {
     return includes(message, matcher);
   } else if (matcher instanceof RegExp) {
     return !!message.match(matcher);
   } else if (matcher) {
-    throw new Error(`[ember-qunit] can only match Strings and RegExps. "${typeof matcher}" was provided.`);
+    throw new Error(
+      `[ember-qunit] can only match Strings and RegExps. "${typeof matcher}" was provided.`
+    );
   }
 
   // No matcher always returns true. Makes the code easier elsewhere.