ember-source 1.8.0.beta.5 → 1.8.0

data/dist/ember-template-compiler.js

@@ -2,6 +2,11 @@
 var Ember = { assert: function() {}, FEATURES: { isEnabled: function() {} } };
 /* global Handlebars:true */
 
+// Remove "use strict"; from transpiled module (in browser builds only) until
+// https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+//
+// REMOVE_USE_STRICT: true
+
 /**
 @module ember
 @submodule ember-handlebars-compiler

data/dist/ember-testing.js

@@ -0,0 +1,1474 @@
+/*!
+ * @overview  Ember - JavaScript Application Framework
+ * @copyright Copyright 2011-2014 Tilde Inc. and contributors
+ *            Portions Copyright 2006-2011 Strobe Inc.
+ *            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   1.8.0
+ */
+
+(function() {
+var enifed, requireModule, eriuqer, requirejs, Ember;
+
+(function() {
+  Ember = this.Ember = this.Ember || {};
+  if (typeof Ember === 'undefined') { Ember = {}; };
+
+  if (typeof Ember.__loader === 'undefined') {
+    var registry = {}, seen = {};
+
+    enifed = function(name, deps, callback) {
+      registry[name] = { deps: deps, callback: callback };
+    };
+
+    requirejs = eriuqer = requireModule = function(name) {
+      if (seen.hasOwnProperty(name)) { return seen[name]; }
+      seen[name] = {};
+
+      if (!registry[name]) {
+        throw new Error("Could not find module " + name);
+      }
+
+      var mod = registry[name];
+      var deps = mod.deps;
+      var callback = mod.callback;
+      var reified = [];
+      var exports;
+
+      for (var i=0, l=deps.length; i<l; i++) {
+        if (deps[i] === 'exports') {
+          reified.push(exports = {});
+        } else {
+          reified.push(requireModule(resolve(deps[i])));
+        }
+      }
+
+      var value = callback.apply(this, reified);
+      return seen[name] = exports || value;
+
+      function resolve(child) {
+        if (child.charAt(0) !== '.') { return child; }
+        var parts = child.split("/");
+        var parentBase = name.split("/").slice(0, -1);
+
+        for (var i=0, l=parts.length; i<l; i++) {
+          var part = parts[i];
+
+          if (part === '..') { parentBase.pop(); }
+          else if (part === '.') { continue; }
+          else { parentBase.push(part); }
+        }
+
+        return parentBase.join("/");
+      }
+    };
+    requirejs._eak_seen = registry;
+
+    Ember.__loader = {define: enifed, require: eriuqer, registry: registry};
+  } else {
+    enifed = Ember.__loader.define;
+    requirejs = eriuqer = requireModule = Ember.__loader.require;
+  }
+})();
+
+enifed("ember-debug",
+  ["ember-metal/core","ember-metal/error","ember-metal/logger"],
+  function(__dependency1__, __dependency2__, __dependency3__) {
+    "use strict";
+    /*global __fail__*/
+
+    var Ember = __dependency1__["default"];
+    var EmberError = __dependency2__["default"];
+    var Logger = __dependency3__["default"];
+
+    /**
+    Ember Debug
+
+    @module ember
+    @submodule ember-debug
+    */
+
+    /**
+    @class Ember
+    */
+
+    /**
+      Define an assertion that will throw an exception if the condition is not
+      met. Ember build tools will remove any calls to `Ember.assert()` when
+      doing a production build. Example:
+
+      ```javascript
+      // Test for truthiness
+      Ember.assert('Must pass a valid object', obj);
+
+      // Fail unconditionally
+      Ember.assert('This code path should never be run');
+      ```
+
+      @method assert
+      @param {String} desc A description of the assertion. This will become
+        the text of the Error thrown if the assertion fails.
+      @param {Boolean} test Must be truthy for the assertion to pass. If
+        falsy, an exception will be thrown.
+    */
+    Ember.assert = function(desc, test) {
+      if (!test) {
+        throw new EmberError("Assertion Failed: " + desc);
+      }
+    };
+
+
+    /**
+      Display a warning with the provided message. Ember build tools will
+      remove any calls to `Ember.warn()` when doing a production build.
+
+      @method warn
+      @param {String} message A warning to display.
+      @param {Boolean} test An optional boolean. If falsy, the warning
+        will be displayed.
+    */
+    Ember.warn = function(message, test) {
+      if (!test) {
+        Logger.warn("WARNING: "+message);
+        if ('trace' in Logger) Logger.trace();
+      }
+    };
+
+    /**
+      Display a debug notice. Ember build tools will remove any calls to
+      `Ember.debug()` when doing a production build.
+
+      ```javascript
+      Ember.debug('I\'m a debug notice!');
+      ```
+
+      @method debug
+      @param {String} message A debug message to display.
+    */
+    Ember.debug = function(message) {
+      Logger.debug("DEBUG: "+message);
+    };
+
+    /**
+      Display a deprecation warning with the provided message and a stack trace
+      (Chrome and Firefox only). Ember build tools will remove any calls to
+      `Ember.deprecate()` when doing a production build.
+
+      @method deprecate
+      @param {String} message A description of the deprecation.
+      @param {Boolean} test An optional boolean. If falsy, the deprecation
+        will be displayed.
+    */
+    Ember.deprecate = function(message, test) {
+      if (test) { return; }
+
+      if (Ember.ENV.RAISE_ON_DEPRECATION) { throw new EmberError(message); }
+
+      var error;
+
+      // When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
+      try { __fail__.fail(); } catch (e) { error = e; }
+
+      if (Ember.LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
+        var stack;
+        var stackStr = '';
+
+        if (error['arguments']) {
+          // Chrome
+          stack = error.stack.replace(/^\s+at\s+/gm, '').
+                              replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2').
+                              replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)').split('\n');
+          stack.shift();
+        } else {
+          // Firefox
+          stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').
+                              replace(/^\(/gm, '{anonymous}(').split('\n');
+        }
+
+        stackStr = "\n    " + stack.slice(2).join("\n    ");
+        message = message + stackStr;
+      }
+
+      Logger.warn("DEPRECATION: "+message);
+    };
+
+
+
+    /**
+      Alias an old, deprecated method with its new counterpart.
+
+      Display a deprecation warning with the provided message and a stack trace
+      (Chrome and Firefox only) when the assigned method is called.
+
+      Ember build tools will not remove calls to `Ember.deprecateFunc()`, though
+      no warnings will be shown in production.
+
+      ```javascript
+      Ember.oldMethod = Ember.deprecateFunc('Please use the new, updated method', Ember.newMethod);
+      ```
+
+      @method deprecateFunc
+      @param {String} message A description of the deprecation.
+      @param {Function} func The new function called to replace its deprecated counterpart.
+      @return {Function} a new function that wrapped the original function with a deprecation warning
+    */
+    Ember.deprecateFunc = function(message, func) {
+      return function() {
+        Ember.deprecate(message);
+        return func.apply(this, arguments);
+      };
+    };
+
+
+    /**
+      Run a function meant for debugging. Ember build tools will remove any calls to
+      `Ember.runInDebug()` when doing a production build.
+
+      ```javascript
+      Ember.runInDebug(function() {
+        Ember.Handlebars.EachView.reopen({
+          didInsertElement: function() {
+            console.log('I\'m happy');
+          }
+        });
+      });
+      ```
+
+      @method runInDebug
+      @param {Function} func The function to be executed.
+      @since 1.5.0
+    */
+    Ember.runInDebug = function(func) {
+      func();
+    };
+
+    // Inform the developer about the Ember Inspector if not installed.
+    if (!Ember.testing) {
+      var isFirefox = typeof InstallTrigger !== 'undefined';
+      var isChrome = !!window.chrome && !window.opera;
+
+      if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+        window.addEventListener("load", function() {
+          if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
+            var downloadURL;
+
+            if(isChrome) {
+              downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
+            } else if(isFirefox) {
+              downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
+            }
+
+            Ember.debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
+          }
+        }, false);
+      }
+    }
+  });
+enifed("ember-testing",
+  ["ember-metal/core","ember-testing/initializers","ember-testing/support","ember-testing/setup_for_testing","ember-testing/test","ember-testing/adapters/adapter","ember-testing/adapters/qunit","ember-testing/helpers"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+
+    // to setup initializer
+         // to handle various edge cases
+
+    var setupForTesting = __dependency4__["default"];
+    var Test = __dependency5__["default"];
+    var Adapter = __dependency6__["default"];
+    var QUnitAdapter = __dependency7__["default"];
+         // adds helpers to helpers object in Test
+
+    /**
+      Ember Testing
+
+      @module ember
+      @submodule ember-testing
+      @requires ember-application
+    */
+
+    Ember.Test = Test;
+    Ember.Test.Adapter = Adapter;
+    Ember.Test.QUnitAdapter = QUnitAdapter;
+    Ember.setupForTesting = setupForTesting;
+  });
+enifed("ember-testing/adapters/adapter",
+  ["ember-metal/core","ember-metal/utils","ember-runtime/system/object","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+    // Ember.K
+    var inspect = __dependency2__.inspect;
+    var EmberObject = __dependency3__["default"];
+
+    /**
+     @module ember
+     @submodule ember-testing
+    */
+
+    /**
+      The primary purpose of this class is to create hooks that can be implemented
+      by an adapter for various test frameworks.
+
+      @class Adapter
+      @namespace Ember.Test
+    */
+    var Adapter = EmberObject.extend({
+      /**
+        This callback will be called whenever an async operation is about to start.
+
+        Override this to call your framework's methods that handle async
+        operations.
+
+        @public
+        @method asyncStart
+      */
+      asyncStart: Ember.K,
+
+      /**
+        This callback will be called whenever an async operation has completed.
+
+        @public
+        @method asyncEnd
+      */
+      asyncEnd: Ember.K,
+
+      /**
+        Override this method with your testing framework's false assertion.
+        This function is called whenever an exception occurs causing the testing
+        promise to fail.
+
+        QUnit example:
+
+        ```javascript
+          exception: function(error) {
+            ok(false, error);
+          };
+        ```
+
+        @public
+        @method exception
+        @param {String} error The exception to be raised.
+      */
+      exception: function(error) {
+        throw error;
+      }
+    });
+
+    __exports__["default"] = Adapter;
+  });
+enifed("ember-testing/adapters/qunit",
+  ["ember-testing/adapters/adapter","ember-metal/utils","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Adapter = __dependency1__["default"];
+    var inspect = __dependency2__.inspect;
+
+    /**
+      This class implements the methods defined by Ember.Test.Adapter for the
+      QUnit testing framework.
+
+      @class QUnitAdapter
+      @namespace Ember.Test
+      @extends Ember.Test.Adapter
+    */
+    __exports__["default"] = Adapter.extend({
+      asyncStart: function() {
+        QUnit.stop();
+      },
+      asyncEnd: function() {
+        QUnit.start();
+      },
+      exception: function(error) {
+        ok(false, inspect(error));
+      }
+    });
+  });
+enifed("ember-testing/helpers",
+  ["ember-metal/property_get","ember-metal/error","ember-metal/run_loop","ember-views/system/jquery","ember-testing/test"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
+    "use strict";
+    var get = __dependency1__.get;
+    var EmberError = __dependency2__["default"];
+    var run = __dependency3__["default"];
+    var jQuery = __dependency4__["default"];
+    var Test = __dependency5__["default"];
+
+    /**
+    * @module ember
+    * @submodule ember-testing
+    */
+
+    var helper = Test.registerHelper;
+    var asyncHelper = Test.registerAsyncHelper;
+    var countAsync = 0;
+
+    function currentRouteName(app){
+      var appController = app.__container__.lookup('controller:application');
+
+      return get(appController, 'currentRouteName');
+    }
+
+    function currentPath(app){
+      var appController = app.__container__.lookup('controller:application');
+
+      return get(appController, 'currentPath');
+    }
+
+    function currentURL(app){
+      var router = app.__container__.lookup('router:main');
+
+      return get(router, 'location').getURL();
+    }
+
+    function visit(app, url) {
+      var router = app.__container__.lookup('router:main');
+      router.location.setURL(url);
+
+      if (app._readinessDeferrals > 0) {
+        router['initialURL'] = url;
+        run(app, 'advanceReadiness');
+        delete router['initialURL'];
+      } else {
+        run(app, app.handleURL, url);
+      }
+
+      return app.testHelpers.wait();
+    }
+
+    function click(app, selector, context) {
+      var $el = app.testHelpers.findWithAssert(selector, context);
+      run($el, 'mousedown');
+
+      if ($el.is(':input')) {
+        var type = $el.prop('type');
+        if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
+          run($el, function(){
+            // Firefox does not trigger the `focusin` event if the window
+            // does not have focus. If the document doesn't have focus just
+            // use trigger('focusin') instead.
+            if (!document.hasFocus || document.hasFocus()) {
+              this.focus();
+            } else {
+              this.trigger('focusin');
+            }
+          });
+        }
+      }
+
+      run($el, 'mouseup');
+      run($el, 'click');
+
+      return app.testHelpers.wait();
+    }
+
+    function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions){
+      var arity = arguments.length;
+      var context, type, options;
+
+      if (arity === 3) {
+        // context and options are optional, so this is
+        // app, selector, type
+        context = null;
+        type = contextOrType;
+        options = {};
+      } else if (arity === 4) {
+        // context and options are optional, so this is
+        if (typeof typeOrOptions === "object") {  // either
+          // app, selector, type, options
+          context = null;
+          type = contextOrType;
+          options = typeOrOptions;
+        } else { // or
+          // app, selector, context, type
+          context = contextOrType;
+          type = typeOrOptions;
+          options = {};
+        }
+      } else {
+        context = contextOrType;
+        type = typeOrOptions;
+        options = possibleOptions;
+      }
+
+      var $el = app.testHelpers.findWithAssert(selector, context);
+
+      var event = jQuery.Event(type, options);
+
+      run($el, 'trigger', event);
+
+      return app.testHelpers.wait();
+    }
+
+    function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
+      var context, type;
+
+      if (typeof keyCode === 'undefined') {
+        context = null;
+        keyCode = typeOrKeyCode;
+        type = contextOrType;
+      } else {
+        context = contextOrType;
+        type = typeOrKeyCode;
+      }
+
+      return app.testHelpers.triggerEvent(selector, context, type, { keyCode: keyCode, which: keyCode });
+    }
+
+    function fillIn(app, selector, contextOrText, text) {
+      var $el, context;
+      if (typeof text === 'undefined') {
+        text = contextOrText;
+      } else {
+        context = contextOrText;
+      }
+      $el = app.testHelpers.findWithAssert(selector, context);
+      run(function() {
+        $el.val(text).change();
+      });
+      return app.testHelpers.wait();
+    }
+
+    function findWithAssert(app, selector, context) {
+      var $el = app.testHelpers.find(selector, context);
+      if ($el.length === 0) {
+        throw new EmberError("Element " + selector + " not found.");
+      }
+      return $el;
+    }
+
+    function find(app, selector, context) {
+      var $el;
+      context = context || get(app, 'rootElement');
+      $el = app.$(selector, context);
+
+      return $el;
+    }
+
+    function andThen(app, callback) {
+      return app.testHelpers.wait(callback(app));
+    }
+
+    function wait(app, value) {
+      return Test.promise(function(resolve) {
+        // If this is the first async promise, kick off the async test
+        if (++countAsync === 1) {
+          Test.adapter.asyncStart();
+        }
+
+        // Every 10ms, poll for the async thing to have finished
+        var watcher = setInterval(function() {
+          // 1. If the router is loading, keep polling
+          var routerIsLoading = !!app.__container__.lookup('router:main').router.activeTransition;
+          if (routerIsLoading) { return; }
+
+          // 2. If there are pending Ajax requests, keep polling
+          if (Test.pendingAjaxRequests) { return; }
+
+          // 3. If there are scheduled timers or we are inside of a run loop, keep polling
+          if (run.hasScheduledTimers() || run.currentRunLoop) { return; }
+          if (Test.waiters && Test.waiters.any(function(waiter) {
+            var context = waiter[0];
+            var callback = waiter[1];
+            return !callback.call(context);
+          })) { return; }
+          // Stop polling
+          clearInterval(watcher);
+
+          // If this is the last async promise, end the async test
+          if (--countAsync === 0) {
+            Test.adapter.asyncEnd();
+          }
+
+          // Synchronously resolve the promise
+          run(null, resolve, value);
+        }, 10);
+      });
+
+    }
+
+
+    /**
+    * Loads a route, sets up any controllers, and renders any templates associated
+    * with the route as though a real user had triggered the route change while
+    * using your app.
+    *
+    * Example:
+    *
+    * ```javascript
+    * visit('posts/index').then(function() {
+    *   // assert something
+    * });
+    * ```
+    *
+    * @method visit
+    * @param {String} url the name of the route
+    * @return {RSVP.Promise}
+    */
+    asyncHelper('visit', visit);
+
+    /**
+    * Clicks an element and triggers any actions triggered by the element's `click`
+    * event.
+    *
+    * Example:
+    *
+    * ```javascript
+    * click('.some-jQuery-selector').then(function() {
+    *   // assert something
+    * });
+    * ```
+    *
+    * @method click
+    * @param {String} selector jQuery selector for finding element on the DOM
+    * @return {RSVP.Promise}
+    */
+    asyncHelper('click', click);
+
+    /**
+    * Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
+    *
+    * Example:
+    *
+    * ```javascript
+    * keyEvent('.some-jQuery-selector', 'keypress', 13).then(function() {
+    *  // assert something
+    * });
+    * ```
+    *
+    * @method keyEvent
+    * @param {String} selector jQuery selector for finding element on the DOM
+    * @param {String} type the type of key event, e.g. `keypress`, `keydown`, `keyup`
+    * @param {Number} keyCode the keyCode of the simulated key event
+    * @return {RSVP.Promise}
+    * @since 1.5.0
+    */
+    asyncHelper('keyEvent', keyEvent);
+
+    /**
+    * Fills in an input element with some text.
+    *
+    * Example:
+    *
+    * ```javascript
+    * fillIn('#email', 'you@example.com').then(function() {
+    *   // assert something
+    * });
+    * ```
+    *
+    * @method fillIn
+    * @param {String} selector jQuery selector finding an input element on the DOM
+    * to fill text with
+    * @param {String} text text to place inside the input element
+    * @return {RSVP.Promise}
+    */
+    asyncHelper('fillIn', fillIn);
+
+    /**
+    * Finds an element in the context of the app's container element. A simple alias
+    * for `app.$(selector)`.
+    *
+    * Example:
+    *
+    * ```javascript
+    * var $el = find('.my-selector');
+    * ```
+    *
+    * @method find
+    * @param {String} selector jQuery string selector for element lookup
+    * @return {Object} jQuery object representing the results of the query
+    */
+    helper('find', find);
+
+    /**
+    * Like `find`, but throws an error if the element selector returns no results.
+    *
+    * Example:
+    *
+    * ```javascript
+    * var $el = findWithAssert('.doesnt-exist'); // throws error
+    * ```
+    *
+    * @method findWithAssert
+    * @param {String} selector jQuery selector string for finding an element within
+    * the DOM
+    * @return {Object} jQuery object representing the results of the query
+    * @throws {Error} throws error if jQuery object returned has a length of 0
+    */
+    helper('findWithAssert', findWithAssert);
+
+    /**
+      Causes the run loop to process any pending events. This is used to ensure that
+      any async operations from other helpers (or your assertions) have been processed.
+
+      This is most often used as the return value for the helper functions (see 'click',
+      'fillIn','visit',etc).
+
+      Example:
+
+      ```javascript
+      Ember.Test.registerAsyncHelper('loginUser', function(app, username, password) {
+        visit('secured/path/here')
+        .fillIn('#username', username)
+        .fillIn('#password', username)
+        .click('.submit')
+
+        return app.testHelpers.wait();
+      });
+
+      @method wait
+      @param {Object} value The value to be returned.
+      @return {RSVP.Promise}
+    */
+    asyncHelper('wait', wait);
+    asyncHelper('andThen', andThen);
+
+
+    /**
+      Returns the currently active route name.
+
+    Example:
+
+    ```javascript
+    function validateRouteName(){
+    equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
+    }
+
+    visit('/some/path').then(validateRouteName)
+    ```
+
+    @method currentRouteName
+    @return {Object} The name of the currently active route.
+    @since 1.5.0
+    */
+    helper('currentRouteName', currentRouteName);
+
+    /**
+      Returns the current path.
+
+    Example:
+
+    ```javascript
+    function validateURL(){
+    equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
+    }
+
+    click('#some-link-id').then(validateURL);
+    ```
+
+    @method currentPath
+    @return {Object} The currently active path.
+    @since 1.5.0
+    */
+    helper('currentPath', currentPath);
+
+    /**
+      Returns the current URL.
+
+    Example:
+
+    ```javascript
+    function validateURL(){
+    equal(currentURL(), '/some/path', "correct URL was transitioned into.");
+    }
+
+    click('#some-link-id').then(validateURL);
+    ```
+
+    @method currentURL
+    @return {Object} The currently active URL.
+    @since 1.5.0
+    */
+    helper('currentURL', currentURL);
+
+    /**
+      Triggers the given DOM event on the element identified by the provided selector.
+
+      Example:
+
+      ```javascript
+      triggerEvent('#some-elem-id', 'blur');
+      ```
+
+      This is actually used internally by the `keyEvent` helper like so:
+
+      ```javascript
+      triggerEvent('#some-elem-id', 'keypress', { keyCode: 13 });
+      ```
+
+     @method triggerEvent
+     @param {String} selector jQuery selector for finding element on the DOM
+     @param {String} [context] jQuery selector that will limit the selector
+                               argument to find only within the context's children
+     @param {String} type The event type to be triggered.
+     @param {Object} [options] The options to be passed to jQuery.Event.
+     @return {RSVP.Promise}
+     @since 1.5.0
+    */
+    asyncHelper('triggerEvent', triggerEvent);
+  });
+enifed("ember-testing/initializers",
+  ["ember-runtime/system/lazy_load"],
+  function(__dependency1__) {
+    "use strict";
+    var onLoad = __dependency1__.onLoad;
+
+    var name = 'deferReadiness in `testing` mode';
+
+    onLoad('Ember.Application', function(Application) {
+      if (!Application.initializers[name]) {
+        Application.initializer({
+          name: name,
+
+          initialize: function(container, application){
+            if (application.testing) {
+              application.deferReadiness();
+            }
+          }
+        });
+      }
+    });
+  });
+enifed("ember-testing/setup_for_testing",
+  ["ember-metal/core","ember-testing/adapters/qunit","ember-views/system/jquery","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+    // import Test from "ember-testing/test";  // ES6TODO: fix when cycles are supported
+    var QUnitAdapter = __dependency2__["default"];
+    var jQuery = __dependency3__["default"];
+
+    var Test, requests;
+
+    function incrementAjaxPendingRequests(_, xhr){
+      requests.push(xhr);
+      Test.pendingAjaxRequests = requests.length;
+    }
+
+    function decrementAjaxPendingRequests(_, xhr){
+      for (var i=0;i<requests.length;i++) {
+        if (xhr === requests[i]) {
+          requests.splice(i, 1);
+        }
+      }
+      Test.pendingAjaxRequests = requests.length;
+    }
+
+    /**
+      Sets Ember up for testing. This is useful to perform
+      basic setup steps in order to unit test.
+
+      Use `App.setupForTesting` to perform integration tests (full
+      application testing).
+
+      @method setupForTesting
+      @namespace Ember
+      @since 1.5.0
+    */
+    __exports__["default"] = function setupForTesting() {
+      if (!Test) { Test = requireModule('ember-testing/test')['default']; }
+
+      Ember.testing = true;
+
+      // if adapter is not manually set default to QUnit
+      if (!Test.adapter) {
+        Test.adapter = QUnitAdapter.create();
+      }
+
+      requests = [];
+      Test.pendingAjaxRequests = requests.length;
+
+      jQuery(document).off('ajaxSend', incrementAjaxPendingRequests);
+      jQuery(document).off('ajaxComplete', decrementAjaxPendingRequests);
+      jQuery(document).on('ajaxSend', incrementAjaxPendingRequests);
+      jQuery(document).on('ajaxComplete', decrementAjaxPendingRequests);
+    }
+  });
+enifed("ember-testing/support",
+  ["ember-metal/core","ember-views/system/jquery"],
+  function(__dependency1__, __dependency2__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+    var jQuery = __dependency2__["default"];
+
+    /**
+      @module ember
+      @submodule ember-testing
+     */
+
+    var $ = jQuery;
+
+    /**
+      This method creates a checkbox and triggers the click event to fire the
+      passed in handler. It is used to correct for a bug in older versions
+      of jQuery (e.g 1.8.3).
+
+      @private
+      @method testCheckboxClick
+    */
+    function testCheckboxClick(handler) {
+      $('<input type="checkbox">')
+        .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
+        .appendTo('body')
+        .on('click', handler)
+        .trigger('click')
+        .remove();
+    }
+
+    $(function() {
+      /*
+        Determine whether a checkbox checked using jQuery's "click" method will have
+        the correct value for its checked property.
+
+        If we determine that the current jQuery version exhibits this behavior,
+        patch it to work correctly as in the commit for the actual fix:
+        https://github.com/jquery/jquery/commit/1fb2f92.
+      */
+      testCheckboxClick(function() {
+        if (!this.checked && !$.event.special.click) {
+          $.event.special.click = {
+            // For checkbox, fire native event so checked state will be right
+            trigger: function() {
+              if ($.nodeName( this, "input" ) && this.type === "checkbox" && this.click) {
+                this.click();
+                return false;
+              }
+            }
+          };
+        }
+      });
+
+      // Try again to verify that the patch took effect or blow up.
+      testCheckboxClick(function() {
+        Ember.warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
+      });
+    });
+  });
+enifed("ember-testing/test",
+  ["ember-metal/core","ember-metal/run_loop","ember-metal/platform","ember-runtime/compare","ember-runtime/ext/rsvp","ember-testing/setup_for_testing","ember-application/system/application","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+    var emberRun = __dependency2__["default"];
+    var create = __dependency3__.create;
+    var compare = __dependency4__["default"];
+    var RSVP = __dependency5__["default"];
+    var setupForTesting = __dependency6__["default"];
+    var EmberApplication = __dependency7__["default"];
+
+    /**
+      @module ember
+      @submodule ember-testing
+     */
+    var slice = [].slice;
+    var helpers = {};
+    var injectHelpersCallbacks = [];
+
+    /**
+      This is a container for an assortment of testing related functionality:
+
+      * Choose your default test adapter (for your framework of choice).
+      * Register/Unregister additional test helpers.
+      * Setup callbacks to be fired when the test helpers are injected into
+        your application.
+
+      @class Test
+      @namespace Ember
+    */
+    var Test = {
+      /**
+        Hash containing all known test helpers.
+
+        @property _helpers
+        @private
+        @since 1.7.0
+      */
+      _helpers: helpers,
+
+      /**
+        `registerHelper` is used to register a test helper that will be injected
+        when `App.injectTestHelpers` is called.
+
+        The helper method will always be called with the current Application as
+        the first parameter.
+
+        For example:
+
+        ```javascript
+        Ember.Test.registerHelper('boot', function(app) {
+          Ember.run(app, app.advanceReadiness);
+        });
+        ```
+
+        This helper can later be called without arguments because it will be
+        called with `app` as the first parameter.
+
+        ```javascript
+        App = Ember.Application.create();
+        App.injectTestHelpers();
+        boot();
+        ```
+
+        @public
+        @method registerHelper
+        @param {String} name The name of the helper method to add.
+        @param {Function} helperMethod
+        @param options {Object}
+      */
+      registerHelper: function(name, helperMethod) {
+        helpers[name] = {
+          method: helperMethod,
+          meta: { wait: false }
+        };
+      },
+
+      /**
+        `registerAsyncHelper` is used to register an async test helper that will be injected
+        when `App.injectTestHelpers` is called.
+
+        The helper method will always be called with the current Application as
+        the first parameter.
+
+        For example:
+
+        ```javascript
+        Ember.Test.registerAsyncHelper('boot', function(app) {
+          Ember.run(app, app.advanceReadiness);
+        });
+        ```
+
+        The advantage of an async helper is that it will not run
+        until the last async helper has completed.  All async helpers
+        after it will wait for it complete before running.
+
+
+        For example:
+
+        ```javascript
+        Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
+          click('.delete-' + postId);
+        });
+
+        // ... in your test
+        visit('/post/2');
+        deletePost(2);
+        visit('/post/3');
+        deletePost(3);
+        ```
+
+        @public
+        @method registerAsyncHelper
+        @param {String} name The name of the helper method to add.
+        @param {Function} helperMethod
+        @since 1.2.0
+      */
+      registerAsyncHelper: function(name, helperMethod) {
+        helpers[name] = {
+          method: helperMethod,
+          meta: { wait: true }
+        };
+      },
+
+      /**
+        Remove a previously added helper method.
+
+        Example:
+
+        ```javascript
+        Ember.Test.unregisterHelper('wait');
+        ```
+
+        @public
+        @method unregisterHelper
+        @param {String} name The helper to remove.
+      */
+      unregisterHelper: function(name) {
+        delete helpers[name];
+        delete Test.Promise.prototype[name];
+      },
+
+      /**
+        Used to register callbacks to be fired whenever `App.injectTestHelpers`
+        is called.
+
+        The callback will receive the current application as an argument.
+
+        Example:
+
+        ```javascript
+        Ember.Test.onInjectHelpers(function() {
+          Ember.$(document).ajaxSend(function() {
+            Test.pendingAjaxRequests++;
+          });
+
+          Ember.$(document).ajaxComplete(function() {
+            Test.pendingAjaxRequests--;
+          });
+        });
+        ```
+
+        @public
+        @method onInjectHelpers
+        @param {Function} callback The function to be called.
+      */
+      onInjectHelpers: function(callback) {
+        injectHelpersCallbacks.push(callback);
+      },
+
+      /**
+        This returns a thenable tailored for testing.  It catches failed
+        `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+        callback in the last chained then.
+
+        This method should be returned by async helpers such as `wait`.
+
+        @public
+        @method promise
+        @param {Function} resolver The function used to resolve the promise.
+      */
+      promise: function(resolver) {
+        return new Test.Promise(resolver);
+      },
+
+      /**
+       Used to allow ember-testing to communicate with a specific testing
+       framework.
+
+       You can manually set it before calling `App.setupForTesting()`.
+
+       Example:
+
+       ```javascript
+       Ember.Test.adapter = MyCustomAdapter.create()
+       ```
+
+       If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
+
+       @public
+       @property adapter
+       @type {Class} The adapter to be used.
+       @default Ember.Test.QUnitAdapter
+      */
+      adapter: null,
+
+      /**
+        Replacement for `Ember.RSVP.resolve`
+        The only difference is this uses
+        an instance of `Ember.Test.Promise`
+
+        @public
+        @method resolve
+        @param {Mixed} The value to resolve
+        @since 1.2.0
+      */
+      resolve: function(val) {
+        return Test.promise(function(resolve) {
+          return resolve(val);
+        });
+      },
+
+      /**
+         This allows ember-testing to play nicely with other asynchronous
+         events, such as an application that is waiting for a CSS3
+         transition or an IndexDB transaction.
+
+         For example:
+
+         ```javascript
+         Ember.Test.registerWaiter(function() {
+           return myPendingTransactions() == 0;
+         });
+         ```
+         The `context` argument allows you to optionally specify the `this`
+         with which your callback will be invoked.
+
+         For example:
+
+         ```javascript
+         Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
+         ```
+
+         @public
+         @method registerWaiter
+         @param {Object} context (optional)
+         @param {Function} callback
+         @since 1.2.0
+      */
+      registerWaiter: function(context, callback) {
+        if (arguments.length === 1) {
+          callback = context;
+          context = null;
+        }
+        if (!this.waiters) {
+          this.waiters = Ember.A();
+        }
+        this.waiters.push([context, callback]);
+      },
+      /**
+         `unregisterWaiter` is used to unregister a callback that was
+         registered with `registerWaiter`.
+
+         @public
+         @method unregisterWaiter
+         @param {Object} context (optional)
+         @param {Function} callback
+         @since 1.2.0
+      */
+      unregisterWaiter: function(context, callback) {
+        var pair;
+        if (!this.waiters) { return; }
+        if (arguments.length === 1) {
+          callback = context;
+          context = null;
+        }
+        pair = [context, callback];
+        this.waiters = Ember.A(this.waiters.filter(function(elt) {
+          return compare(elt, pair)!==0;
+        }));
+      }
+    };
+
+    function helper(app, name) {
+      var fn = helpers[name].method;
+      var meta = helpers[name].meta;
+
+      return function() {
+        var args = slice.call(arguments);
+        var lastPromise = Test.lastPromise;
+
+        args.unshift(app);
+
+        // some helpers are not async and
+        // need to return a value immediately.
+        // example: `find`
+        if (!meta.wait) {
+          return fn.apply(app, args);
+        }
+
+        if (!lastPromise) {
+          // It's the first async helper in current context
+          lastPromise = fn.apply(app, args);
+        } else {
+          // wait for last helper's promise to resolve
+          // and then execute
+          run(function() {
+            lastPromise = Test.resolve(lastPromise).then(function() {
+              return fn.apply(app, args);
+            });
+          });
+        }
+
+        return lastPromise;
+      };
+    }
+
+    function run(fn) {
+      if (!emberRun.currentRunLoop) {
+        emberRun(fn);
+      } else {
+        fn();
+      }
+    }
+
+    EmberApplication.reopen({
+      /**
+       This property contains the testing helpers for the current application. These
+       are created once you call `injectTestHelpers` on your `Ember.Application`
+       instance. The included helpers are also available on the `window` object by
+       default, but can be used from this object on the individual application also.
+
+        @property testHelpers
+        @type {Object}
+        @default {}
+      */
+      testHelpers: {},
+
+      /**
+       This property will contain the original methods that were registered
+       on the `helperContainer` before `injectTestHelpers` is called.
+
+       When `removeTestHelpers` is called, these methods are restored to the
+       `helperContainer`.
+
+        @property originalMethods
+        @type {Object}
+        @default {}
+        @private
+        @since 1.3.0
+      */
+      originalMethods: {},
+
+
+      /**
+      This property indicates whether or not this application is currently in
+      testing mode. This is set when `setupForTesting` is called on the current
+      application.
+
+      @property testing
+      @type {Boolean}
+      @default false
+      @since 1.3.0
+      */
+      testing: false,
+
+      /**
+       This hook defers the readiness of the application, so that you can start
+       the app when your tests are ready to run. It also sets the router's
+       location to 'none', so that the window's location will not be modified
+       (preventing both accidental leaking of state between tests and interference
+       with your testing framework).
+
+       Example:
+
+      ```
+      App.setupForTesting();
+      ```
+
+        @method setupForTesting
+      */
+      setupForTesting: function() {
+        setupForTesting();
+
+        this.testing = true;
+
+        this.Router.reopen({
+          location: 'none'
+        });
+      },
+
+      /**
+        This will be used as the container to inject the test helpers into. By
+        default the helpers are injected into `window`.
+
+        @property helperContainer
+        @type {Object} The object to be used for test helpers.
+        @default window
+        @since 1.2.0
+      */
+      helperContainer: window,
+
+      /**
+        This injects the test helpers into the `helperContainer` object. If an object is provided
+        it will be used as the helperContainer. If `helperContainer` is not set it will default
+        to `window`. If a function of the same name has already been defined it will be cached
+        (so that it can be reset if the helper is removed with `unregisterHelper` or
+        `removeTestHelpers`).
+
+       Any callbacks registered with `onInjectHelpers` will be called once the
+       helpers have been injected.
+
+      Example:
+      ```
+      App.injectTestHelpers();
+      ```
+
+        @method injectTestHelpers
+      */
+      injectTestHelpers: function(helperContainer) {
+        if (helperContainer) { this.helperContainer = helperContainer; }
+
+        this.testHelpers = {};
+        for (var name in helpers) {
+          this.originalMethods[name] = this.helperContainer[name];
+          this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+          protoWrap(Test.Promise.prototype, name, helper(this, name), helpers[name].meta.wait);
+        }
+
+        for(var i = 0, l = injectHelpersCallbacks.length; i < l; i++) {
+          injectHelpersCallbacks[i](this);
+        }
+      },
+
+      /**
+        This removes all helpers that have been registered, and resets and functions
+        that were overridden by the helpers.
+
+        Example:
+
+        ```javascript
+        App.removeTestHelpers();
+        ```
+
+        @public
+        @method removeTestHelpers
+      */
+      removeTestHelpers: function() {
+        for (var name in helpers) {
+          this.helperContainer[name] = this.originalMethods[name];
+          delete this.testHelpers[name];
+          delete this.originalMethods[name];
+        }
+      }
+    });
+
+    // This method is no longer needed
+    // But still here for backwards compatibility
+    // of helper chaining
+    function protoWrap(proto, name, callback, isAsync) {
+      proto[name] = function() {
+        var args = arguments;
+        if (isAsync) {
+          return callback.apply(this, args);
+        } else {
+          return this.then(function() {
+            return callback.apply(this, args);
+          });
+        }
+      };
+    }
+
+    Test.Promise = function() {
+      RSVP.Promise.apply(this, arguments);
+      Test.lastPromise = this;
+    };
+
+    Test.Promise.prototype = create(RSVP.Promise.prototype);
+    Test.Promise.prototype.constructor = Test.Promise;
+
+    // Patch `then` to isolate async methods
+    // specifically `Ember.Test.lastPromise`
+    var originalThen = RSVP.Promise.prototype.then;
+    Test.Promise.prototype.then = function(onSuccess, onFailure) {
+      return originalThen.call(this, function(val) {
+        return isolate(onSuccess, val);
+      }, onFailure);
+    };
+
+    // This method isolates nested async methods
+    // so that they don't conflict with other last promises.
+    //
+    // 1. Set `Ember.Test.lastPromise` to null
+    // 2. Invoke method
+    // 3. Return the last promise created during method
+    // 4. Restore `Ember.Test.lastPromise` to original value
+    function isolate(fn, val) {
+      var value, lastPromise;
+
+      // Reset lastPromise for nested helpers
+      Test.lastPromise = null;
+
+      value = fn(val);
+
+      lastPromise = Test.lastPromise;
+
+      // If the method returned a promise
+      // return that promise. If not,
+      // return the last async helper's promise
+      if ((value && (value instanceof Test.Promise)) || !lastPromise) {
+        return value;
+      } else {
+        run(function() {
+          lastPromise = Test.resolve(lastPromise).then(function() {
+            return value;
+          });
+        });
+        return lastPromise;
+      }
+    }
+
+    __exports__["default"] = Test;
+  });
+requireModule("ember-testing");
+
+})();