Merge branch 'master' into open638_rebase

platform/commonUI/browse/bundle.js

@@ -34,6 +34,7 @@ define([
     "./src/windowing/NewTabAction",
     "./src/windowing/FullscreenAction",
     "./src/creation/CreateActionProvider",
+    "./src/creation/AddActionProvider",
     "./src/creation/CreationService",
     "./src/windowing/WindowTitler",
     'legacyRegistry'
@@ -50,6 +51,7 @@ define([
     NewTabAction,
     FullscreenAction,
     CreateActionProvider,
+    AddActionProvider,
     CreationService,
     WindowTitler,
     legacyRegistry
@@ -117,7 +119,8 @@ define([
                     "implementation": LocatorController,
                     "depends": [
                         "$scope",
-                        "$timeout"
+                        "$timeout",
+                        "objectService"
                     ]
                 },
                 {
@@ -279,6 +282,18 @@ define([
                         "policyService"
                     ]
                 },
+                {
+                    "key": "AddActionProvider",
+                    "provides": "actionService",
+                    "type": "provider",
+                    "implementation": AddActionProvider,
+                    "depends": [
+                        "$q",
+                        "typeService",
+                        "dialogService",
+                        "policyService"
+                    ]
+                },
                 {
                     "key": "CreationService",
                     "provides": "creationService",

platform/commonUI/browse/lib/screenfull.min.js

@@ -1,6 +0,0 @@
-/*!
-* screenfull
-* v1.2.0 - 2014-04-29
-* (c) Sindre Sorhus; MIT License
-*/
-!function(){"use strict";var a="undefined"!=typeof module&&module.exports,b="undefined"!=typeof Element&&"ALLOW_KEYBOARD_INPUT"in Element,c=function(){for(var a,b,c=[["requestFullscreen","exitFullscreen","fullscreenElement","fullscreenEnabled","fullscreenchange","fullscreenerror"],["webkitRequestFullscreen","webkitExitFullscreen","webkitFullscreenElement","webkitFullscreenEnabled","webkitfullscreenchange","webkitfullscreenerror"],["webkitRequestFullScreen","webkitCancelFullScreen","webkitCurrentFullScreenElement","webkitCancelFullScreen","webkitfullscreenchange","webkitfullscreenerror"],["mozRequestFullScreen","mozCancelFullScreen","mozFullScreenElement","mozFullScreenEnabled","mozfullscreenchange","mozfullscreenerror"],["msRequestFullscreen","msExitFullscreen","msFullscreenElement","msFullscreenEnabled","MSFullscreenChange","MSFullscreenError"]],d=0,e=c.length,f={};e>d;d++)if(a=c[d],a&&a[1]in document){for(d=0,b=a.length;b>d;d++)f[c[0][d]]=a[d];return f}return!1}(),d={request:function(a){var d=c.requestFullscreen;a=a||document.documentElement,/5\.1[\.\d]* Safari/.test(navigator.userAgent)?a[d]():a[d](b&&Element.ALLOW_KEYBOARD_INPUT)},exit:function(){document[c.exitFullscreen]()},toggle:function(a){this.isFullscreen?this.exit():this.request(a)},onchange:function(){},onerror:function(){},raw:c};return c?(Object.defineProperties(d,{isFullscreen:{get:function(){return!!document[c.fullscreenElement]}},element:{enumerable:!0,get:function(){return document[c.fullscreenElement]}},enabled:{enumerable:!0,get:function(){return!!document[c.fullscreenEnabled]}}}),document.addEventListener(c.fullscreenchange,function(a){d.onchange.call(d,a)}),document.addEventListener(c.fullscreenerror,function(a){d.onerror.call(d,a)}),void(a?module.exports=d:window.screenfull=d)):void(a?module.exports=!1:window.screenfull=!1)}();

platform/commonUI/browse/src/creation/AddAction.js

@@ -0,0 +1,139 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining AddAction. Created by ahenry on 01/21/16.
+ */
+define(
+    [
+        './CreateWizard'
+    ],
+    function (CreateWizard) {
+        "use strict";
+
+        /**
+         * The Add Action is performed to create new instances of
+         * domain objects of a specific type that are subobjects of an
+         * object being edited. This is the action that is performed when a
+         * user uses the Add menu option.
+         *
+         * @memberof platform/commonUI/browse
+         * @implements {Action}
+         * @constructor
+         *
+         * @param {Type} type the type of domain object to create
+         * @param {DomainObject} parent the domain object that should
+         *        act as a container for the newly-created object
+         *        (note that the user will have an opportunity to
+         *        override this)
+         * @param {ActionContext} context the context in which the
+         *        action is being performed
+         * @param {DialogService} dialogService
+         */
+        function AddAction(type, parent, context, $q, dialogService, policyService) {
+            this.metadata = {
+                key: 'add',
+                glyph: type.getGlyph(),
+                name: type.getName(),
+                type: type.getKey(),
+                description: type.getDescription(),
+                context: context
+            };
+
+            this.type = type;
+            this.parent = parent;
+            this.$q = $q;
+            this.dialogService = dialogService;
+            this.policyService = policyService;
+        }
+
+        /**
+         *
+         * Create a new object of the given type.
+         * This will prompt for user input first.
+         *
+         * @returns {Promise} that will be resolved with the object that the
+         * action was originally invoked on (ie. the 'parent')
+         */
+        AddAction.prototype.perform = function () {
+            var newModel = this.type.getInitialModel(),
+                newObject,
+                parentObject = this.parent,
+                wizard;
+
+            newModel.type = this.type.getKey();
+            newObject = parentObject.getCapability('instantiation').instantiate(newModel);
+            newObject.useCapability('mutation', function(model){
+                model.location = parentObject.getId();
+            });
+
+            wizard = new CreateWizard(newObject, this.parent, this.policyService);
+
+            function populateObjectFromInput (formValue) {
+                return wizard.populateObjectFromInput(formValue, newObject);
+            }
+
+            function addToParent (populatedObject) {
+                parentObject.getCapability('composition').add(populatedObject);
+                return parentObject.getCapability('persistence').persist().then(function(){
+                    return parentObject;
+                });
+            }
+
+            function save(object) {
+                /*
+                It's necessary to persist the new sub-object in order
+                 that it can be retrieved for composition in the parent.
+                 Future refactoring that allows temporary objects to be
+                 retrieved from object services will make this unnecessary.
+                 */
+                return object.getCapability('editor').save(true);
+            }
+
+            return this.dialogService
+                .getUserInput(wizard.getFormStructure(false), wizard.getInitialFormValue())
+                .then(populateObjectFromInput)
+                .then(save)
+                .then(addToParent);
+
+        };
+
+
+        /**
+         * Metadata associated with a Add action.
+         * @typedef {ActionMetadata} AddActionMetadata
+         * @property {string} type the key for the type of domain object
+         *           to be created
+         */
+
+        /**
+         * Get metadata about this action.
+         * @returns {AddActionMetadata} metadata about this action
+         */
+        AddAction.prototype.getMetadata = function () {
+           return this.metadata;
+        };
+
+        return AddAction;
+    }
+);

platform/commonUI/browse/src/creation/AddActionProvider.js

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise*/
+
+/**
+ * Module defining AddActionProvider.js. Created by ahenry on 01/21/16.
+ */
+define(
+    ["./AddAction"],
+    function (AddAction) {
+        "use strict";
+
+        /**
+         * The AddActionProvider is an ActionProvider which introduces
+         * an Add action for creating sub objects.
+         *
+         * @memberof platform/commonUI/browse
+         * @constructor
+         * @implements {ActionService}
+         *
+         * @param {TypeService} typeService the type service, used to discover
+         *        available types
+         * @param {DialogService} dialogService the dialog service, used by
+         *        specific Create actions to get user input to populate the
+         *        model of the newly-created domain object.
+         * @param {CreationService} creationService the creation service (also
+         *        introduced in this bundle), responsible for handling actual
+         *        object creation.
+         */
+        function AddActionProvider($q, typeService, dialogService, policyService) {
+            this.typeService = typeService;
+            this.dialogService = dialogService;
+            this.$q = $q;
+            this.policyService = policyService;
+        }
+
+        AddActionProvider.prototype.getActions = function (actionContext) {
+            var context = actionContext || {},
+                key = context.key,
+                destination = context.domainObject,
+                self = this;
+
+            // We only provide Add actions, and we need a
+            // domain object to serve as the container for the
+            // newly-created object (although the user may later
+            // make a different selection)
+            if (key !== 'add' || !destination) {
+                return [];
+            }
+
+            // Introduce one create action per type
+            return this.typeService.listTypes().filter(function (type) {
+                return self.policyService.allow("creation", type) && self.policyService.allow("composition", destination.getCapability('type'), type);
+            }).map(function (type) {
+                return new AddAction(
+                    type,
+                    destination,
+                    context,
+                    self.$q,
+                    self.dialogService,
+                    self.policyService
+                );
+            });
+        };
+
+        return AddActionProvider;
+    }
+);

platform/commonUI/browse/src/creation/CreateWizard.js

@@ -26,18 +26,21 @@ define(
         'use strict';
 
         /**
-         * Construct a new CreateWizard.
+         * A class for capturing user input data from an object creation
+         * dialog, and populating a domain object with that data.
          *
-         * @param {TypeImpl} type the type of domain object to be created
+         * @param {DomainObject} domainObject the newly created object to
+         * populate with user input
          * @param {DomainObject} parent the domain object to serve as
          *        the initial parent for the created object, in the dialog
          * @memberof platform/commonUI/browse
          * @constructor
          */
-        function CreateWizard(type, parent, policyService, initialModel) {
-            this.type = type;
-            this.model = initialModel || type.getInitialModel();
-            this.properties = type.getProperties();
+        function CreateWizard(domainObject, parent, policyService) {
+            this.type = domainObject.getCapability('type');
+            this.model = domainObject.getModel();
+            this.domainObject = domainObject;
+            this.properties = this.type.getProperties();
             this.parent = parent;
             this.policyService = policyService;
         }
@@ -46,11 +49,14 @@ define(
          * Get the form model for this wizard; this is a description
          * that will be rendered to an HTML form. See the
          * platform/forms bundle
-         *
+         * @param {boolean} includeLocation if true, a 'location' section
+         * will be included that will allow the user to select the location
+         * of the newly created object, otherwise the .location property of
+         * the model will be used.
          * @return {FormModel} formModel the form model to
          *         show in the create dialog
          */
-        CreateWizard.prototype.getFormStructure = function () {
+        CreateWizard.prototype.getFormStructure = function (includeLocation) {
             var sections = [],
                 type = this.type,
                 policyService = this.policyService;
@@ -84,12 +90,16 @@ define(
             });
 
             // Ensure there is always a "save in" section
-            sections.push({ name: 'Location', rows: [{
-                name: "Save In",
-                control: "locator",
-                validate: validateLocation,
-                key: "createParent"
-            }]});
+            if (includeLocation) {
+                sections.push({
+                    name: 'Location', rows: [{
+                        name: "Save In",
+                        control: "locator",
+                        validate: validateLocation,
+                        key: "createParent"
+                    }]
+                });
+            }
 
             return {
                 sections: sections,
@@ -97,6 +107,23 @@ define(
             };
         };
 
+        /**
+         * Given some form input values and a domain object, populate the
+         * domain object used to create this wizard from the given form values.
+         * @param formValue
+         * @returns {DomainObject}
+         */
+        CreateWizard.prototype.populateObjectFromInput = function(formValue) {
+            var parent = this.getLocation(formValue),
+                formModel = this.createModel(formValue);
+
+            formModel.location = parent.getId();
+            this.domainObject.useCapability("mutation", function(){
+                return formModel;
+            });
+            return this.domainObject;
+        };
+
         /**
          * Get the initial value for the form being described.
          * This will include the values for all properties described
@@ -120,6 +147,7 @@ define(
         /**
          * Based on a populated form, get the domain object which
          * should be used as a parent for the newly-created object.
+         * @private
          * @return {DomainObject}
          */
         CreateWizard.prototype.getLocation = function (formValue) {
@@ -129,6 +157,7 @@ define(
         /**
          * Create the domain object model for a newly-created object,
          * based on user input read from a formModel.
+         * @private
          * @return {object} the domain object model
          */
         CreateWizard.prototype.createModel = function (formValue) {

platform/commonUI/browse/src/creation/LocatorController.js

@@ -33,7 +33,7 @@ define(
          * @memberof platform/commonUI/browse
          * @constructor
          */
-        function LocatorController($scope, $timeout) {
+        function LocatorController($scope, $timeout, objectService) {
             // Populate values needed by the locator control. These are:
             // * rootObject: The top-level object, since we want to show
             //               the full tree
@@ -52,6 +52,18 @@ define(
                         $scope.rootObject =
                             (context && context.getRoot()) || $scope.rootObject;
                     }, 0);
+                } else if (!contextRoot){
+                    //If no context root is available, default to the root
+                    // object
+                    $scope.rootObject = undefined;
+                    // Update the displayed tree on a timeout to avoid
+                    // an infinite digest exception.
+                    objectService.getObjects(['ROOT'])
+                        .then(function(objects){
+                            $timeout(function () {
+                                $scope.rootObject = objects.ROOT;
+                            }, 0);
+                        });
                 }
 
                 $scope.treeModel.selectedObject = domainObject;

platform/commonUI/browse/src/windowing/FullscreenAction.js

@@ -25,7 +25,7 @@
  * Module defining FullscreenAction. Created by vwoeltje on 11/18/14.
  */
 define(
-    ["../../lib/screenfull.min"],
+    ["screenfull"],
     function () {
         "use strict";
 

platform/commonUI/browse/test/creation/AddActionProviderSpec.js

@@ -0,0 +1,137 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define,Promise,describe,it,expect,beforeEach,waitsFor,jasmine,xit,xdescribe*/
+
+/**
+ * MCTRepresentationSpec. Created by ahenry on 01/21/14.
+ */
+define(
+    ["../../src/creation/AddActionProvider"],
+    function (AddActionProvider) {
+        "use strict";
+
+        describe("The add action provider", function () {
+            var mockTypeService,
+                mockDialogService,
+                mockPolicyService,
+                mockCreationPolicy,
+                mockCompositionPolicy,
+                mockPolicyMap = {},
+                mockTypes,
+                mockDomainObject,
+                mockQ,
+                provider;
+
+            function createMockType(name) {
+                var mockType = jasmine.createSpyObj(
+                    "type" + name,
+                    [
+                        "getKey",
+                        "getGlyph",
+                        "getName",
+                        "getDescription",
+                        "getProperties",
+                        "getInitialModel",
+                        "hasFeature"
+                    ]
+                );
+                mockType.hasFeature.andReturn(true);
+                mockType.getName.andReturn(name);
+                return mockType;
+            }
+
+            beforeEach(function () {
+                mockTypeService = jasmine.createSpyObj(
+                    "typeService",
+                    [ "listTypes" ]
+                );
+                mockDialogService = jasmine.createSpyObj(
+                    "dialogService",
+                    [ "getUserInput" ]
+                );
+                mockPolicyService = jasmine.createSpyObj(
+                    "policyService",
+                    [ "allow" ]
+                );
+
+                mockDomainObject = jasmine.createSpyObj(
+                    "domainObject",
+                    [ "getCapability" ]
+                );
+
+                //Mocking getCapability because AddActionProvider uses the
+                // type capability of the destination object.
+                mockDomainObject.getCapability.andReturn({});
+
+                mockTypes = [ "A", "B", "C" ].map(createMockType);
+
+                mockTypes.forEach(function(type){
+                    mockPolicyMap[type.getName()] = true;
+                });
+
+                mockCreationPolicy = function(type){
+                    return mockPolicyMap[type.getName()];
+                };
+
+                mockCompositionPolicy = function(){
+                    return true;
+                };
+
+                mockPolicyService.allow.andReturn(true);
+
+                mockTypeService.listTypes.andReturn(mockTypes);
+
+                provider = new AddActionProvider(
+                    mockQ,
+                    mockTypeService,
+                    mockDialogService,
+                    mockPolicyService
+                );
+            });
+
+            it("checks for creatability", function () {
+                provider.getActions({
+                    key: "add",
+                    domainObject: mockDomainObject
+                });
+                // Make sure it was creation which was used to check
+                expect(mockPolicyService.allow)
+                    .toHaveBeenCalledWith("creation", mockTypes[0]);
+            });
+
+            it("checks for composability of type", function () {
+                provider.getActions({
+                    key: "add",
+                    domainObject: mockDomainObject
+                });
+
+                expect(mockPolicyService.allow).toHaveBeenCalledWith(
+                    "composition",
+                    jasmine.any(Object),
+                    jasmine.any(Object)
+                );
+
+                expect(mockDomainObject.getCapability).toHaveBeenCalledWith('type');
+            });
+        });
+    }
+);

platform/commonUI/browse/test/creation/CreateActionProviderSpec.js

@@ -32,11 +32,12 @@ define(
         describe("The create action provider", function () {
             var mockTypeService,
                 mockDialogService,
-                mockCreationService,
+                mockNavigationService,
                 mockPolicyService,
                 mockCreationPolicy,
                 mockPolicyMap = {},
                 mockTypes,
+                mockQ,
                 provider;
 
             function createMockType(name) {
@@ -66,9 +67,9 @@ define(
                     "dialogService",
                     [ "getUserInput" ]
                 );
-                mockCreationService = jasmine.createSpyObj(
-                    "creationService",
-                    [ "createObject" ]
+                mockNavigationService = jasmine.createSpyObj(
+                    "navigationService",
+                    [ "setNavigation" ]
                 );
                 mockPolicyService = jasmine.createSpyObj(
                     "policyService",
@@ -92,15 +93,14 @@ define(
                 mockTypeService.listTypes.andReturn(mockTypes);
 
                 provider = new CreateActionProvider(
+                    mockQ,
                     mockTypeService,
-                    mockDialogService,
-                    mockCreationService,
+                    mockNavigationService,
                     mockPolicyService
                 );
             });
 
-            //TODO: Disabled for NEM Beta
-            xit("exposes one create action per type", function () {
+            it("exposes one create action per type", function () {
                 expect(provider.getActions({
                     key: "create",
                     domainObject: {}
@@ -114,8 +114,7 @@ define(
                 }).length).toEqual(0);
             });
 
-            //TODO: Disabled for NEM Beta
-            xit("does not expose non-creatable types", function () {
+            it("does not expose non-creatable types", function () {
                 // One of the types won't have the creation feature...
                 mockPolicyMap[mockTypes[0].getName()] = false;
                 // ...so it should have been filtered out.

platform/commonUI/browse/test/creation/CreateWizardSpec.js

@@ -35,6 +35,7 @@ define(
                 mockProperties,
                 mockPolicyService,
                 testModel,
+                mockDomainObject,
                 wizard;
 
             function createMockProperty(name) {
@@ -81,8 +82,18 @@ define(
                 mockType.getInitialModel.andReturn(testModel);
                 mockType.getProperties.andReturn(mockProperties);
 
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['getCapability', 'useCapability', 'getModel']
+                );
+
+                //Mocking the getCapability('type') call
+                mockDomainObject.getCapability.andReturn(mockType);
+                mockDomainObject.useCapability.andReturn();
+                mockDomainObject.getModel.andReturn(testModel);
+
                 wizard = new CreateWizard(
-                    mockType,
+                    mockDomainObject,
                     mockParent,
                     mockPolicyService
                 );
@@ -130,6 +141,18 @@ define(
                 });
             });
 
+            it("populates the model on the associated object", function () {
+                var formValue = {
+                    "A": "ValueA",
+                    "B": "ValueB",
+                    "C": "ValueC"
+                    },
+                    compareModel = wizard.createModel(formValue);
+                wizard.populateObjectFromInput(formValue);
+                expect(mockDomainObject.useCapability).toHaveBeenCalledWith('mutation', jasmine.any(Function));
+                expect(mockDomainObject.useCapability.mostRecentCall.args[1]()).toEqual(compareModel);
+            });
+
             it("validates selection types using policy", function () {
                 var mockDomainObject = jasmine.createSpyObj(
                         'domainObject',
@@ -139,7 +162,8 @@ define(
                         'otherType',
                         ['getKey']
                     ),
-                    structure = wizard.getFormStructure(),
+                    //Create a form structure with location
+                    structure = wizard.getFormStructure(true),
                     sections = structure.sections,
                     rows = structure.sections[sections.length - 1].rows,
                     locationRow = rows[rows.length - 1];
@@ -156,6 +180,12 @@ define(
                 );
             });
 
+            it("creates a form model without a location if not requested", function () {
+                expect(wizard.getFormStructure(false).sections.some(function(section){
+                    return section.name === 'Location';
+                })).toEqual(false);
+            });
+
 
         });
     }

platform/commonUI/browse/test/creation/LocatorControllerSpec.js

@@ -35,6 +35,8 @@ define(
                 mockDomainObject,
                 mockRootObject,
                 mockContext,
+                mockObjectService,
+                getObjectsPromise,
                 controller;
 
             beforeEach(function () {
@@ -55,73 +57,106 @@ define(
                     "context",
                     [ "getRoot" ]
                 );
+                mockObjectService = jasmine.createSpyObj(
+                    "objectService",
+                    ["getObjects"]
+                );
+                getObjectsPromise = jasmine.createSpyObj(
+                    "promise",
+                    ["then"]
+                );
 
                 mockDomainObject.getCapability.andReturn(mockContext);
                 mockContext.getRoot.andReturn(mockRootObject);
+                mockObjectService.getObjects.andReturn(getObjectsPromise);
 
                 mockScope.ngModel = {};
                 mockScope.field = "someField";
 
-                controller = new LocatorController(mockScope, mockTimeout);
+                controller = new LocatorController(mockScope, mockTimeout, mockObjectService);
             });
+                describe("when context is available", function () {
 
-            it("adds a treeModel to scope", function () {
-                expect(mockScope.treeModel).toBeDefined();
-            });
+                    beforeEach(function () {
+                        mockContext.getRoot.andReturn(mockRootObject);
+                        controller = new LocatorController(mockScope, mockTimeout, mockObjectService);
+                    });
 
-            it("watches for changes to treeModel", function () {
-                // This is what the embedded tree representation
-                // will be modifying.
-                expect(mockScope.$watch).toHaveBeenCalledWith(
-                    "treeModel.selectedObject",
-                    jasmine.any(Function)
-                );
-            });
+                    it("adds a treeModel to scope", function () {
+                        expect(mockScope.treeModel).toBeDefined();
+                    });
 
-            it("changes its own model on embedded model updates", function () {
-                // Need to pass on selection changes as updates to
-                // the control's value
-                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
-                mockTimeout.mostRecentCall.args[0]();
-                expect(mockScope.ngModel.someField).toEqual(mockDomainObject);
-                expect(mockScope.rootObject).toEqual(mockRootObject);
+                    it("watches for changes to treeModel", function () {
+                        // This is what the embedded tree representation
+                        // will be modifying.
+                        expect(mockScope.$watch).toHaveBeenCalledWith(
+                            "treeModel.selectedObject",
+                            jasmine.any(Function)
+                        );
+                    });
 
-                // Verify that the capability we expect to have been used
-                // was used.
-                expect(mockDomainObject.getCapability)
-                    .toHaveBeenCalledWith("context");
-            });
+                    it("changes its own model on embedded model updates", function () {
+                        // Need to pass on selection changes as updates to
+                        // the control's value
+                        mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                        mockTimeout.mostRecentCall.args[0]();
+                        expect(mockScope.ngModel.someField).toEqual(mockDomainObject);
+                        expect(mockScope.rootObject).toEqual(mockRootObject);
 
-            it("rejects changes which fail validation", function () {
-                mockScope.structure = { validate: jasmine.createSpy('validate') };
-                mockScope.structure.validate.andReturn(false);
+                        // Verify that the capability we expect to have been used
+                        // was used.
+                        expect(mockDomainObject.getCapability)
+                            .toHaveBeenCalledWith("context");
+                    });
 
-                // Pass selection change
-                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
-                mockTimeout.mostRecentCall.args[0]();
+                    it("rejects changes which fail validation", function () {
+                        mockScope.structure = { validate: jasmine.createSpy('validate') };
+                        mockScope.structure.validate.andReturn(false);
 
-                expect(mockScope.structure.validate).toHaveBeenCalled();
-                // Change should have been rejected
-                expect(mockScope.ngModel.someField).not.toEqual(mockDomainObject);
-            });
+                        // Pass selection change
+                        mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                        mockTimeout.mostRecentCall.args[0]();
 
-            it("treats a lack of a selection as invalid", function () {
-                mockScope.ngModelController = jasmine.createSpyObj(
-                    'ngModelController',
-                    [ '$setValidity' ]
-                );
+                        expect(mockScope.structure.validate).toHaveBeenCalled();
+                        // Change should have been rejected
+                        expect(mockScope.ngModel.someField).not.toEqual(mockDomainObject);
+                    });
 
-                mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
-                mockTimeout.mostRecentCall.args[0]();
-                expect(mockScope.ngModelController.$setValidity)
-                    .toHaveBeenCalledWith(jasmine.any(String), true);
+                    it("treats a lack of a selection as invalid", function () {
+                        mockScope.ngModelController = jasmine.createSpyObj(
+                            'ngModelController',
+                            [ '$setValidity' ]
+                        );
 
-                mockScope.$watch.mostRecentCall.args[1](undefined);
-                mockTimeout.mostRecentCall.args[0]();
-                expect(mockScope.ngModelController.$setValidity)
-                    .toHaveBeenCalledWith(jasmine.any(String), false);
-            });
+                        mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                        mockTimeout.mostRecentCall.args[0]();
+                        expect(mockScope.ngModelController.$setValidity)
+                            .toHaveBeenCalledWith(jasmine.any(String), true);
 
+                        mockScope.$watch.mostRecentCall.args[1](undefined);
+                        mockTimeout.mostRecentCall.args[0]();
+                        expect(mockScope.ngModelController.$setValidity)
+                            .toHaveBeenCalledWith(jasmine.any(String), false);
+                    });
+                });
+                describe("when no context is available", function () {
+                    var defaultRoot = "DEFAULT_ROOT";
+
+                    beforeEach(function () {
+                        mockContext.getRoot.andReturn(undefined);
+                        getObjectsPromise.then.andCallFake(function(callback){
+                            callback({'ROOT':defaultRoot});
+                        });
+                        controller = new LocatorController(mockScope, mockTimeout, mockObjectService);
+                    });
+
+                    it("provides a default context where none is available", function () {
+                        mockScope.$watch.mostRecentCall.args[1](mockDomainObject);
+                        mockTimeout.mostRecentCall.args[0]();
+                        expect(mockScope.rootObject).toBe(defaultRoot);
+
+                    });
+                });
         });
     }
 );