[Framework] Fill in spec for bundle resolver

Fill in spec for bundle resolver, WTD-518.

platform/framework/src/resolve/BundleResolver.js

@@ -81,7 +81,8 @@ define(
                  * Resolve all extensions exposed by these bundles.
                  *
                  * @param {Bundle[]} bundles the bundles to resolve
-                 * @returns {Object.<string, object[]>} an object containing
+                 * @returns {Promise.<Object.<string, object[]>>} an promise
+                 *          for an object containing
                  *          key-value pairs, where keys are extension
                  *          categories and values are arrays of resolved
                  *          extensions belonging to those categories

platform/framework/test/resolve/BundleResolverSpec.js

@@ -1,14 +1,54 @@
-/*global define,Promise,describe,it,expect,beforeEach*/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine,runs*/
 
 /**
  * BundleResolverSpec. Created by vwoeltje on 11/6/14.
  */
 define(
-    [],
+    ["../../src/resolve/BundleResolver", "../../src/load/Bundle"],
-    function () {
+    function (BundleResolver, Bundle) {
         "use strict";
 
-        describe("", function () {
+        describe("The bundle resolver", function () {
+            var mockExtensionResolver,
+                mockLog,
+                resolver;
+
+            beforeEach(function () {
+                mockExtensionResolver = jasmine.createSpyObj(
+                    "extensionResolver",
+                    ["resolve"]
+                );
+                mockLog = jasmine.createSpyObj(
+                    "$log",
+                    ["error", "warn", "info", "debug"]
+                );
+                resolver = new BundleResolver(mockExtensionResolver, mockLog);
+            });
+
+            it("invokes the extension resolver for all bundle extensions", function () {
+                var result;
+
+                mockExtensionResolver.resolve.andReturn(Promise.resolve("a"));
+
+                resolver.resolveBundles([
+                    new Bundle("x", { extensions: { tests: [ {}, {}, {} ] } }),
+                    new Bundle("y", { extensions: { tests: [ {}, {} ], others: [ {}, {} ] } }),
+                    new Bundle("z", { extensions: { others: [ {} ] } })
+                ]).then(function (v) { result = v; });
+
+                waitsFor(
+                    function () { return result !== undefined; },
+                    "promise resolution",
+                    250
+                );
+
+                // Should get back the result from the resolver, and
+                // should be binned by extension category.
+                runs(function () {
+                    expect(result.tests).toEqual(["a", "a", "a", "a", "a"]);
+                    expect(result.others).toEqual(["a", "a", "a"]);
+                });
+            });
 
         });
     }