ember-source 2.17.0.beta.6 → 2.17.0

data/dist/ember-tests.prod.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.17.0-beta.6
+ * @version   2.17.0
  */
 
 var enifed, requireModule, Ember;
@@ -47244,6 +47244,24 @@ enifed('ember-runtime/tests/computed/reduce_computed_macros_test', ['ember-metal
     deepEqual(obj.get('filtered'), [20, 22, 24], 'computed array is updated when array is changed');
   });
 
+  QUnit.test('it updates properly on @each with {} dependencies', function () {
+    var item = _object.default.create({ prop: true });
+
+    obj = _object.default.extend({
+      filtered: (0, _reduce_computed_macros.filter)('items.@each.{prop}', function (item) {
+        return item.get('prop') === true;
+      })
+    }).create({
+      items: (0, _native_array.A)([item])
+    });
+
+    deepEqual(obj.get('filtered'), [item]);
+
+    item.set('prop', false);
+
+    deepEqual(obj.get('filtered'), []);
+  });
+
   QUnit.module('filterBy', {
     setup: function () {
       obj = _object.default.extend({
@@ -47545,7 +47563,7 @@ enifed('ember-runtime/tests/computed/reduce_computed_macros_test', ['ember-metal
         array: (0, _native_array.A)([1, 2, 3, 4, 5, 6, 7]),
         array2: (0, _native_array.A)([3, 4, 5])
       });
-    }, /Ember\.computed\.setDiff requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');
+    }, /\`Ember\.computed\.setDiff\` requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');
 
     expectAssertion(function () {
       _object.default.extend({
@@ -47555,7 +47573,7 @@ enifed('ember-runtime/tests/computed/reduce_computed_macros_test', ['ember-metal
         array2: (0, _native_array.A)([3, 4, 5]),
         array3: (0, _native_array.A)([7])
       });
-    }, /Ember\.computed\.setDiff requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');
+    }, /\`Ember\.computed\.setDiff\` requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');
   });
 
   QUnit.test('it has set-diff semantics', function () {
@@ -49039,12 +49057,10 @@ enifed('ember-runtime/tests/ext/rsvp_test', ['ember-metal', 'ember-runtime/ext/r
     try {
       (0, _emberMetal.run)(_rsvp.default, 'reject', 'foo');
     } catch (e) {
-      ok(false, 'should not throw');
+      equal(e, 'foo', 'should throw with rejection message');
     } finally {
       (0, _emberDebug.setTesting)(wasEmberTesting);
     }
-
-    ok(true);
   });
 
   QUnit.test('Can reject with no arguments', function () {
@@ -61389,12 +61405,13 @@ enifed('ember-testing/tests/adapters/qunit_test', ['ember-metal', 'ember-testing
 enifed('ember-testing/tests/adapters_test', ['ember-metal', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit', 'ember-application'], function (_emberMetal, _test, _adapter, _qunit, _emberApplication) {
   'use strict';
 
-  var App, originalAdapter, originalQUnit;
+  var App, originalAdapter, originalQUnit, originalWindowOnerror;
 
   QUnit.module('ember-testing Adapters', {
     setup: function () {
       originalAdapter = _test.default.adapter;
       originalQUnit = window.QUnit;
+      originalWindowOnerror = window.onerror;
     },
     teardown: function () {
       if (App) {
@@ -61405,6 +61422,7 @@ enifed('ember-testing/tests/adapters_test', ['ember-metal', 'ember-testing/test'
 
       _test.default.adapter = originalAdapter;
       window.QUnit = originalQUnit;
+      window.onerror = originalWindowOnerror;
     }
   });
 
@@ -61454,21 +61472,27 @@ enifed('ember-testing/tests/adapters_test', ['ember-metal', 'ember-testing/test'
     ok(!(_test.default.adapter instanceof _qunit.default));
   });
 
-  QUnit.test('With Ember.Test.adapter set, errors in Ember.run are caught', function () {
+  QUnit.test('With Ember.Test.adapter set, errors in synchronous Ember.run are bubbled out', function (assert) {
     var thrown = new Error('Boom!');
 
-    var caught = void 0;
+    var caughtInAdapter = void 0,
+        caughtInCatch = void 0;
     _test.default.adapter = _qunit.default.create({
       exception: function (error) {
-        caught = error;
+        caughtInAdapter = error;
       }
     });
 
-    (0, _emberMetal.run)(function () {
-      throw thrown;
-    });
+    try {
+      (0, _emberMetal.run)(function () {
+        throw thrown;
+      });
+    } catch (e) {
+      caughtInCatch = e;
+    }
 
-    deepEqual(caught, thrown);
+    assert.equal(caughtInAdapter, undefined, 'test adapter should never receive synchronous errors');
+    assert.equal(caughtInCatch, thrown, 'a "normal" try/catch should catch errors in sync run');
   });
 });
 enifed('ember-testing/tests/ext/rsvp_test', ['ember-testing/ext/rsvp', 'ember-testing/test/adapter', 'ember-testing/test/promise', 'ember-metal', 'ember-debug'], function (_rsvp, _adapter, _promise, _emberMetal, _emberDebug) {
@@ -64054,57 +64078,309 @@ enifed('ember/tests/error_handler_test', ['ember', 'ember-metal'], function (_em
   var ADAPTER = _ember.default.Test && _ember.default.Test.adapter;
   var TESTING = _ember.default.testing;
 
+  var WINDOW_ONERROR = void 0;
+
   QUnit.module('error_handler', {
+    setup: function () {
+      // capturing this outside of module scope to ensure we grab
+      // the test frameworks own window.onerror to reset it
+      WINDOW_ONERROR = window.onerror;
+    },
     teardown: function () {
       _ember.default.onerror = ONERROR;
       _ember.default.testing = TESTING;
+      window.onerror = WINDOW_ONERROR;
       if (_ember.default.Test) {
         _ember.default.Test.adapter = ADAPTER;
       }
     }
   });
 
-  function runThatThrows(message) {
+  function runThatThrowsSync() {
+    var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Error for testing error handling';
+
     return (0, _emberMetal.run)(function () {
       throw new Error(message);
     });
   }
 
-  test('by default there is no onerror', function (assert) {
-    _ember.default.onerror = undefined;
-    assert.throws(runThatThrows, Error);
-    assert.equal(_ember.default.onerror, undefined);
+  test('by default there is no onerror - sync run', function (assert) {
+    assert.strictEqual(_ember.default.onerror, undefined, 'precond - there should be no Ember.onerror set by default');
+    assert.throws(runThatThrowsSync, Error, 'errors thrown sync are catchable');
   });
 
-  test('when Ember.onerror is registered', function (assert) {
+  test('when Ember.onerror (which rethrows) is registered - sync run', function (assert) {
     assert.expect(2);
     _ember.default.onerror = function (error) {
       assert.ok(true, 'onerror called');
       throw error;
     };
-    assert.throws(runThatThrows, Error);
-    // Ember.onerror = ONERROR;
+    assert.throws(runThatThrowsSync, Error, 'error is thrown');
+  });
+
+  test('when Ember.onerror (which does not rethrow) is registered - sync run', function (assert) {
+    assert.expect(2);
+    _ember.default.onerror = function () {
+      assert.ok(true, 'onerror called');
+    };
+    runThatThrowsSync();
+    assert.ok(true, 'no error was thrown, Ember.onerror can intercept errors');
   });
 
-  QUnit.test('Ember.run does not swallow exceptions by default (Ember.testing = true)', function () {
+  QUnit.test('does not swallow exceptions by default (Ember.testing = true, no Ember.onerror) - sync run', function (assert) {
     _ember.default.testing = true;
+
     var error = new Error('the error');
-    throws(function () {
+    assert.throws(function () {
       _ember.default.run(function () {
         throw error;
       });
     }, error);
   });
 
-  QUnit.test('Ember.run does not swallow exceptions by default (Ember.testing = false)', function () {
+  QUnit.test('does not swallow exceptions by default (Ember.testing = false, no Ember.onerror) - sync run', function (assert) {
     _ember.default.testing = false;
     var error = new Error('the error');
-    throws(function () {
+    assert.throws(function () {
+      _ember.default.run(function () {
+        throw error;
+      });
+    }, error);
+  });
+
+  QUnit.test('does not swallow exceptions (Ember.testing = false, Ember.onerror which rethrows) - sync run', function (assert) {
+    assert.expect(2);
+    _ember.default.testing = false;
+
+    _ember.default.onerror = function (error) {
+      assert.ok(true, 'Ember.onerror was called');
+      throw error;
+    };
+
+    var error = new Error('the error');
+    assert.throws(function () {
       _ember.default.run(function () {
         throw error;
       });
     }, error);
   });
+
+  QUnit.test('Ember.onerror can intercept errors (aka swallow) by not rethrowing (Ember.testing = false) - sync run', function (assert) {
+    assert.expect(1);
+    _ember.default.testing = false;
+
+    _ember.default.onerror = function () {
+      assert.ok(true, 'Ember.onerror was called');
+    };
+
+    var error = new Error('the error');
+    try {
+      _ember.default.run(function () {
+        throw error;
+      });
+    } catch (e) {
+      assert.notOk(true, 'Ember.onerror that does not rethrow is intentionally swallowing errors, try / catch wrapping does not see error');
+    }
+  });
+
+  QUnit.test('does not swallow exceptions by default (Ember.testing = true, no Ember.onerror) - async run', function (assert) {
+    var done = assert.async();
+    var caughtByWindowOnerror = void 0;
+
+    _ember.default.testing = true;
+
+    window.onerror = function (message) {
+      caughtByWindowOnerror = message;
+      // prevent "bubbling" and therefore failing the test
+      return true;
+    };
+
+    _ember.default.run.later(function () {
+      throw new Error('the error');
+    }, 10);
+
+    setTimeout(function () {
+      assert.pushResult({
+        result: /the error/.test(caughtByWindowOnerror),
+        actual: caughtByWindowOnerror,
+        expected: 'to include `the error`',
+        message: 'error should bubble out to window.onerror, and therefore fail tests (due to QUnit implementing window.onerror)'
+      });
+
+      done();
+    }, 20);
+  });
+
+  QUnit.test('does not swallow exceptions by default (Ember.testing = false, no Ember.onerror) - async run', function (assert) {
+    var done = assert.async();
+    var caughtByWindowOnerror = void 0;
+
+    _ember.default.testing = false;
+
+    window.onerror = function (message) {
+      caughtByWindowOnerror = message;
+      // prevent "bubbling" and therefore failing the test
+      return true;
+    };
+
+    _ember.default.run.later(function () {
+      throw new Error('the error');
+    }, 10);
+
+    setTimeout(function () {
+      assert.pushResult({
+        result: /the error/.test(caughtByWindowOnerror),
+        actual: caughtByWindowOnerror,
+        expected: 'to include `the error`',
+        message: 'error should bubble out to window.onerror, and therefore fail tests (due to QUnit implementing window.onerror)'
+      });
+
+      done();
+    }, 20);
+  });
+
+  QUnit.test('Ember.onerror can intercept errors (aka swallow) by not rethrowing (Ember.testing = false) - async run', function (assert) {
+    var done = assert.async();
+
+    _ember.default.testing = false;
+
+    window.onerror = function () {
+      assert.notOk(true, 'window.onerror is never invoked when Ember.onerror intentionally swallows errors');
+      // prevent "bubbling" and therefore failing the test
+      return true;
+    };
+
+    var thrown = new Error('the error');
+    _ember.default.onerror = function (error) {
+      assert.strictEqual(error, thrown, 'Ember.onerror is called with the error');
+    };
+
+    _ember.default.run.later(function () {
+      throw thrown;
+    }, 10);
+
+    setTimeout(done, 20);
+  });
+
+  function generateRSVPErrorHandlingTests(message, generatePromise) {
+    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10;
+
+    test(message + ' when Ember.onerror which does not rethrow is present - rsvp', function (assert) {
+      assert.expect(1);
+
+      var thrown = new Error('the error');
+      _ember.default.onerror = function (error) {
+        assert.strictEqual(error, thrown, 'Ember.onerror is called for errors thrown in RSVP promises');
+      };
+
+      generatePromise(thrown);
+
+      // RSVP.Promise's are configured to settle within the run loop, this
+      // ensures that run loop has completed
+      return new _ember.default.RSVP.Promise(function (resolve) {
+        return setTimeout(resolve, timeout);
+      });
+    });
+
+    test(message + ' when Ember.onerror which does rethrow is present - rsvp', function (assert) {
+      assert.expect(2);
+
+      var thrown = new Error('the error');
+      _ember.default.onerror = function (error) {
+        assert.strictEqual(error, thrown, 'Ember.onerror is called for errors thrown in RSVP promises');
+        throw error;
+      };
+
+      window.onerror = function (message) {
+        assert.pushResult({
+          result: /the error/.test(message),
+          actual: message,
+          expected: 'to include `the error`',
+          message: 'error should bubble out to window.onerror, and therefore fail tests (due to QUnit implementing window.onerror)'
+        });
+
+        // prevent "bubbling" and therefore failing the test
+        return true;
+      };
+
+      generatePromise(thrown);
+
+      // RSVP.Promise's are configured to settle within the run loop, this
+      // ensures that run loop has completed
+      return new _ember.default.RSVP.Promise(function (resolve) {
+        return setTimeout(resolve, timeout);
+      });
+    });
+
+    test(message + ' when Ember.onerror which does not rethrow is present (Ember.testing = false) - rsvp', function (assert) {
+      assert.expect(1);
+
+      _ember.default.testing = false;
+      var thrown = new Error('the error');
+      _ember.default.onerror = function (error) {
+        assert.strictEqual(error, thrown, 'Ember.onerror is called for errors thrown in RSVP promises');
+      };
+
+      generatePromise(thrown);
+
+      // RSVP.Promise's are configured to settle within the run loop, this
+      // ensures that run loop has completed
+      return new _ember.default.RSVP.Promise(function (resolve) {
+        return setTimeout(resolve, timeout);
+      });
+    });
+
+    test(message + ' when Ember.onerror which does rethrow is present (Ember.testing = false) - rsvp', function (assert) {
+      assert.expect(2);
+
+      _ember.default.testing = false;
+      var thrown = new Error('the error');
+      _ember.default.onerror = function (error) {
+        assert.strictEqual(error, thrown, 'Ember.onerror is called for errors thrown in RSVP promises');
+        throw error;
+      };
+
+      window.onerror = function (message) {
+        assert.pushResult({
+          result: /the error/.test(message),
+          actual: message,
+          expected: 'to include `the error`',
+          message: 'error should bubble out to window.onerror, and therefore fail tests (due to QUnit implementing window.onerror)'
+        });
+
+        // prevent "bubbling" and therefore failing the test
+        return true;
+      };
+
+      generatePromise(thrown);
+
+      // RSVP.Promise's are configured to settle within the run loop, this
+      // ensures that run loop has completed
+      return new _ember.default.RSVP.Promise(function (resolve) {
+        return setTimeout(resolve, timeout);
+      });
+    });
+  }
+
+  generateRSVPErrorHandlingTests('errors in promise constructor', function (error) {
+    new _ember.default.RSVP.Promise(function () {
+      throw error;
+    });
+  });
+
+  generateRSVPErrorHandlingTests('errors in promise .then callback', function (error) {
+    _ember.default.RSVP.resolve().then(function () {
+      throw error;
+    });
+  });
+
+  generateRSVPErrorHandlingTests('errors in async promise .then callback', function (error) {
+    new _ember.default.RSVP.Promise(function (resolve) {
+      return setTimeout(resolve, 10);
+    }).then(function () {
+      throw error;
+    });
+  }, 20);
 });
 enifed('ember/tests/global-api-test', ['ember-metal', 'ember-runtime'], function (_emberMetal, _emberRuntime) {
   'use strict';

data/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.17.0-beta.6
+ * @version   2.17.0
  */
 
 var enifed, requireModule, Ember;
@@ -9646,13 +9646,10 @@ enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel)
                     }
                 }
             }
-            var onError = getOnError(this.options);
-            if (onError) {
-                try {
-                    return method.apply(target, args);
-                } catch (error) {
-                    onError(error);
-                }
+            if (length === 1) {
+                return method();
+            } else if (length === 2) {
+                return method.call(target);
             } else {
                 return method.apply(target, args);
             }
@@ -26829,22 +26826,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     cache = {};
   }
 
-  // To maintain stacktrace consistency across browsers
-  var getStack = function (error) {
-    var stack = error.stack;
-    var message = error.message;
-
-    if (stack && stack.indexOf(message) === -1) {
-      stack = message + '\n' + stack;
-    }
-
-    return stack;
-  };
-
   var onerror = void 0;
   var onErrorTarget = {
     get onerror() {
-      return dispatchOverride || onerror;
+      return onerror;
     }
   };
 
@@ -26858,14 +26843,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   var dispatchOverride = void 0;
-  // dispatch error
-  function dispatchError(error) {
-    if (dispatchOverride) {
-      dispatchOverride(error);
-    } else {
-      defaultDispatch(error);
-    }
-  }
 
   // allows testing adapter to override dispatch
   function getDispatchOverride() {
@@ -26875,17 +26852,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     dispatchOverride = handler;
   }
 
-  function defaultDispatch(error) {
-    if (emberDebug.isTesting()) {
-      throw error;
-    }
-    if (onerror) {
-      onerror(error);
-    } else {
-      Logger.error(getStack(error));
-    }
-  }
-
   /**
    @module @ember/utils
   */
@@ -30046,7 +30012,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   exports.instrumentationUnsubscribe = unsubscribe;
   exports.getOnerror = getOnerror;
   exports.setOnerror = setOnerror;
-  exports.dispatchError = dispatchError;
   exports.setDispatchOverride = setDispatchOverride;
   exports.getDispatchOverride = getDispatchOverride;
   exports.META_DESC = META_DESC;
@@ -35667,7 +35632,10 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
   @module @ember/object
   */
 
-  function reduceMacro(dependentKey, callback, initialValue) {
+  function reduceMacro(dependentKey, callback, initialValue, name) {
+    (true && !(!/[\[\]\{\}]/g.test(dependentKey)) && (0, _emberDebug.assert)('Dependent key passed to `Ember.computed.' + name + '` shouldn\'t contain brace expanding pattern.', !/[\[\]\{\}]/g.test(dependentKey)));
+
+
     var cp = new _emberMetal.ComputedProperty(function () {
       var arr = (0, _emberMetal.get)(this, dependentKey);
       if (arr === null || typeof arr !== 'object') {
@@ -35696,12 +35664,20 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
       } else {
         return (0, _native_array.A)();
       }
-    }, { dependentKeys: [dependentKey], readOnly: true });
+    }, { readOnly: true });
+
+    cp.property(dependentKey); // this forces to expand properties GH #15855
 
     return cp;
   }
 
-  function multiArrayMacro(_dependentKeys, callback) {
+  function multiArrayMacro(_dependentKeys, callback, name) {
+    (true && !(_dependentKeys.every(function (dependentKey) {
+      return !/[\[\]\{\}]/g.test(dependentKey);
+    })) && (0, _emberDebug.assert)('Dependent keys passed to `Ember.computed.' + name + '` shouldn\'t contain brace expanding pattern.', _dependentKeys.every(function (dependentKey) {
+      return !/[\[\]\{\}]/g.test(dependentKey);
+    })));
+
     var dependentKeys = _dependentKeys.map(function (key) {
       return key + '.[]';
     });
@@ -35728,7 +35704,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
   function sum(dependentKey) {
     return reduceMacro(dependentKey, function (sum, item) {
       return sum + item;
-    }, 0);
+    }, 0, 'sum');
   }
 
   /**
@@ -35776,7 +35752,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
   function max(dependentKey) {
     return reduceMacro(dependentKey, function (max, item) {
       return Math.max(max, item);
-    }, -Infinity);
+    }, -Infinity, 'max');
   }
 
   /**
@@ -35824,7 +35800,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
   function min(dependentKey) {
     return reduceMacro(dependentKey, function (min, item) {
       return Math.min(min, item);
-    }, Infinity);
+    }, Infinity, 'min');
   }
 
   /**
@@ -35900,7 +35876,8 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function mapBy(dependentKey, propertyKey) {
-    (true && !(typeof propertyKey === 'string') && (0, _emberDebug.assert)('Ember.computed.mapBy expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string'));
+    (true && !(typeof propertyKey === 'string') && (0, _emberDebug.assert)('\`Ember.computed.mapBy\` expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string'));
+    (true && !(!/[\[\]\{\}]/g.test(dependentKey)) && (0, _emberDebug.assert)('Dependent key passed to `Ember.computed.mapBy` shouldn\'t contain brace expanding pattern.', !/[\[\]\{\}]/g.test(dependentKey)));
 
 
     return map(dependentKey + '.@each.' + propertyKey, function (item) {
@@ -36003,8 +35980,10 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function filterBy(dependentKey, propertyKey, value) {
-    var callback = void 0;
+    (true && !(!/[\[\]\{\}]/g.test(dependentKey)) && (0, _emberDebug.assert)('Dependent key passed to `Ember.computed.filterBy` shouldn\'t contain brace expanding pattern.', !/[\[\]\{\}]/g.test(dependentKey)));
+
 
+    var callback = void 0;
     if (arguments.length === 2) {
       callback = function (item) {
         return (0, _emberMetal.get)(item, propertyKey);
@@ -36071,7 +36050,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
       });
 
       return uniq;
-    });
+    }, 'uniq');
   }
 
   /**
@@ -36105,6 +36084,9 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function uniqBy(dependentKey, propertyKey) {
+    (true && !(!/[\[\]\{\}]/g.test(dependentKey)) && (0, _emberDebug.assert)('Dependent key passed to `Ember.computed.uniqBy` shouldn\'t contain brace expanding pattern.', !/[\[\]\{\}]/g.test(dependentKey)));
+
+
     var cp = new _emberMetal.ComputedProperty(function () {
       var uniq = (0, _native_array.A)();
       var seen = Object.create(null);
@@ -36218,7 +36200,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
         }
 
         return true;
-      });
+      }, 'intersect');
 
       return (0, _native_array.A)(results);
     });
@@ -36258,7 +36240,8 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function setDiff(setAProperty, setBProperty) {
-    (true && !(arguments.length === 2) && (0, _emberDebug.assert)('Ember.computed.setDiff requires exactly two dependent arrays.', arguments.length === 2));
+    (true && !(arguments.length === 2) && (0, _emberDebug.assert)('\`Ember.computed.setDiff\` requires exactly two dependent arrays.', arguments.length === 2));
+    (true && !(!/[\[\]\{\}]/g.test(setAProperty) && !/[\[\]\{\}]/g.test(setBProperty)) && (0, _emberDebug.assert)('Dependent keys passed to `Ember.computed.setDiff` shouldn\'t contain brace expanding pattern.', !/[\[\]\{\}]/g.test(setAProperty) && !/[\[\]\{\}]/g.test(setBProperty)));
 
 
     var cp = new _emberMetal.ComputedProperty(function () {
@@ -36328,7 +36311,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
         }
       }
       return res;
-    });
+    }, 'collect');
   }
 
   /**
@@ -36398,7 +36381,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-utils
     @public
   */
   function sort(itemsKey, sortDefinition) {
-    (true && !(arguments.length === 2) && (0, _emberDebug.assert)('Ember.computed.sort requires two arguments: an array key to sort and ' + 'either a sort properties key or sort function', arguments.length === 2));
+    (true && !(arguments.length === 2) && (0, _emberDebug.assert)('\`Ember.computed.sort\` requires two arguments: an array key to sort and ' + 'either a sort properties key or sort function', arguments.length === 2));
 
 
     if (typeof sortDefinition === 'function') {
@@ -36833,7 +36816,12 @@ enifed('ember-runtime/ext/rsvp', ['exports', 'rsvp', 'ember-metal', 'ember-debug
   function onerrorDefault(reason) {
     var error = errorFor(reason);
     if (error) {
-      (0, _emberMetal.dispatchError)(error);
+      var overrideDispatch = (0, _emberMetal.getDispatchOverride)();
+      if (overrideDispatch) {
+        overrideDispatch(error);
+      } else {
+        throw error;
+      }
     }
   }
 
@@ -44913,7 +44901,7 @@ enifed('ember-testing/test/adapter', ['exports', 'ember-console', 'ember-metal']
 
   function setAdapter(value) {
     adapter = value;
-    if (value) {
+    if (value && typeof value.exception === 'function') {
       (0, _emberMetal.setDispatchOverride)(adapterDispatch);
     } else {
       (0, _emberMetal.setDispatchOverride)(null);
@@ -48509,7 +48497,7 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.17.0-beta.6";
+  exports.default = "2.17.0";
 });
 enifed("handlebars", ["exports"], function (exports) {
   "use strict";