2015-05-13 23:42:35 +00:00
|
|
|
/*****************************************************************************
|
2016-07-12 23:21:58 +00:00
|
|
|
* Open MCT, Copyright (c) 2014-2016, United States Government
|
2015-05-13 23:42:35 +00:00
|
|
|
* as represented by the Administrator of the National Aeronautics and Space
|
|
|
|
* Administration. All rights reserved.
|
|
|
|
*
|
2016-07-12 23:21:58 +00:00
|
|
|
* Open MCT is licensed under the Apache License, Version 2.0 (the
|
2015-05-13 23:42:35 +00:00
|
|
|
* "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.
|
|
|
|
*
|
2016-07-12 23:21:58 +00:00
|
|
|
* Open MCT includes source code licensed under additional open source
|
2015-05-13 23:42:35 +00:00
|
|
|
* 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.
|
|
|
|
*****************************************************************************/
|
2014-11-24 21:39:52 +00:00
|
|
|
|
|
|
|
define(
|
2014-12-30 21:40:42 +00:00
|
|
|
["../../src/controllers/TreeNodeController"],
|
2014-11-24 21:39:52 +00:00
|
|
|
function (TreeNodeController) {
|
|
|
|
|
|
|
|
describe("The tree node controller", function () {
|
2014-11-24 23:10:29 +00:00
|
|
|
var mockScope,
|
2014-12-05 23:48:13 +00:00
|
|
|
mockTimeout,
|
2015-08-25 21:49:38 +00:00
|
|
|
mockDomainObject,
|
2014-11-24 23:10:29 +00:00
|
|
|
controller;
|
|
|
|
|
|
|
|
function TestObject(id, context) {
|
|
|
|
return {
|
2016-05-19 18:29:13 +00:00
|
|
|
getId: function () {
|
|
|
|
return id;
|
|
|
|
},
|
2014-11-24 23:10:29 +00:00
|
|
|
getCapability: function (key) {
|
|
|
|
return key === 'context' ? context : undefined;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
beforeEach(function () {
|
2015-08-25 21:49:38 +00:00
|
|
|
mockScope = jasmine.createSpyObj("$scope", ["$watch", "$on", "$emit"]);
|
2014-12-05 23:48:13 +00:00
|
|
|
mockTimeout = jasmine.createSpy("$timeout");
|
2015-08-25 21:49:38 +00:00
|
|
|
mockDomainObject = jasmine.createSpyObj(
|
|
|
|
"domainObject",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getId", "getCapability", "getModel", "useCapability"]
|
2015-08-25 21:49:38 +00:00
|
|
|
);
|
2015-09-18 21:54:37 +00:00
|
|
|
|
2015-09-22 18:14:55 +00:00
|
|
|
controller = new TreeNodeController(mockScope, mockTimeout);
|
2014-11-24 23:10:29 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
it("allows tracking of expansion state", function () {
|
|
|
|
// The tree node tracks whether or not it has ever
|
|
|
|
// been expanded in order to lazily load the expanded
|
|
|
|
// portion of the tree.
|
|
|
|
expect(controller.hasBeenExpanded()).toBeFalsy();
|
|
|
|
controller.trackExpansion();
|
2014-12-05 23:48:13 +00:00
|
|
|
|
|
|
|
// Expansion is tracked on a timeout, because too
|
|
|
|
// much expansion can result in an unstable digest.
|
|
|
|
expect(mockTimeout).toHaveBeenCalled();
|
|
|
|
mockTimeout.mostRecentCall.args[0]();
|
|
|
|
|
2014-11-24 23:10:29 +00:00
|
|
|
expect(controller.hasBeenExpanded()).toBeTruthy();
|
|
|
|
controller.trackExpansion();
|
|
|
|
expect(controller.hasBeenExpanded()).toBeTruthy();
|
|
|
|
});
|
|
|
|
|
|
|
|
it("tracks whether or not the represented object is currently navigated-to", function () {
|
|
|
|
// This is needed to highlight the current selection
|
|
|
|
var mockContext = jasmine.createSpyObj(
|
|
|
|
"context",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-11-24 23:10:29 +00:00
|
|
|
),
|
|
|
|
obj = new TestObject("test-object", mockContext);
|
|
|
|
|
|
|
|
mockContext.getPath.andReturn([obj]);
|
|
|
|
|
|
|
|
// Verify precondition
|
2014-12-04 01:26:02 +00:00
|
|
|
expect(controller.isSelected()).toBeFalsy();
|
2014-11-24 23:10:29 +00:00
|
|
|
|
2014-12-04 01:59:37 +00:00
|
|
|
// Change the represented domain object
|
|
|
|
mockScope.domainObject = obj;
|
2014-11-24 23:10:29 +00:00
|
|
|
|
2014-12-04 01:59:37 +00:00
|
|
|
// Invoke the watch with the new selection
|
|
|
|
mockScope.$watch.calls[0].args[1](obj);
|
|
|
|
|
|
|
|
expect(controller.isSelected()).toBeTruthy();
|
2014-11-24 23:10:29 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
it("expands a node if it is on the navigation path", function () {
|
|
|
|
var mockParentContext = jasmine.createSpyObj(
|
|
|
|
"parentContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-11-24 23:10:29 +00:00
|
|
|
),
|
|
|
|
mockChildContext = jasmine.createSpyObj(
|
|
|
|
"childContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-11-24 23:10:29 +00:00
|
|
|
),
|
|
|
|
parent = new TestObject("parent", mockParentContext),
|
|
|
|
child = new TestObject("child", mockChildContext);
|
|
|
|
|
|
|
|
mockChildContext.getParent.andReturn(parent);
|
|
|
|
mockChildContext.getPath.andReturn([parent, child]);
|
|
|
|
mockParentContext.getPath.andReturn([parent]);
|
|
|
|
|
|
|
|
// Set up such that we are on, but not at the end of, a path
|
2014-12-04 01:26:02 +00:00
|
|
|
mockScope.ngModel = { selectedObject: child };
|
2014-11-24 23:10:29 +00:00
|
|
|
mockScope.domainObject = parent;
|
|
|
|
mockScope.toggle = jasmine.createSpyObj("toggle", ["setState"]);
|
|
|
|
|
2014-12-04 01:59:37 +00:00
|
|
|
// Invoke the watch with the new selection
|
|
|
|
mockScope.$watch.calls[0].args[1](child);
|
|
|
|
|
2014-12-05 23:48:13 +00:00
|
|
|
// Expansion is tracked on a timeout, because too
|
|
|
|
// much expansion can result in an unstable digest.
|
|
|
|
// Trigger that timeout.
|
|
|
|
expect(mockTimeout).toHaveBeenCalled();
|
|
|
|
mockTimeout.mostRecentCall.args[0]();
|
|
|
|
|
2014-12-04 01:59:37 +00:00
|
|
|
expect(mockScope.toggle.setState).toHaveBeenCalledWith(true);
|
|
|
|
expect(controller.hasBeenExpanded()).toBeTruthy();
|
|
|
|
expect(controller.isSelected()).toBeFalsy();
|
2014-11-24 23:10:29 +00:00
|
|
|
|
|
|
|
});
|
|
|
|
|
2014-12-17 23:41:44 +00:00
|
|
|
it("does not expand a node if it is not on the navigation path", function () {
|
|
|
|
var mockParentContext = jasmine.createSpyObj(
|
|
|
|
"parentContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-12-17 23:41:44 +00:00
|
|
|
),
|
|
|
|
mockChildContext = jasmine.createSpyObj(
|
|
|
|
"childContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-12-17 23:41:44 +00:00
|
|
|
),
|
|
|
|
parent = new TestObject("parent", mockParentContext),
|
|
|
|
child = new TestObject("child", mockChildContext);
|
|
|
|
|
|
|
|
mockChildContext.getParent.andReturn(parent);
|
|
|
|
mockChildContext.getPath.andReturn([child, child]);
|
|
|
|
mockParentContext.getPath.andReturn([parent]);
|
|
|
|
|
|
|
|
// Set up such that we are on, but not at the end of, a path
|
|
|
|
mockScope.ngModel = { selectedObject: child };
|
|
|
|
mockScope.domainObject = parent;
|
|
|
|
mockScope.toggle = jasmine.createSpyObj("toggle", ["setState"]);
|
|
|
|
|
|
|
|
// Invoke the watch with the new selection
|
|
|
|
mockScope.$watch.calls[0].args[1](child);
|
|
|
|
|
|
|
|
// Expansion is tracked on a timeout, because too
|
|
|
|
// much expansion can result in an unstable digest.
|
|
|
|
// We want to make sure no timeouts are pending here.
|
|
|
|
expect(mockTimeout).not.toHaveBeenCalled();
|
|
|
|
expect(controller.hasBeenExpanded()).toBeFalsy();
|
|
|
|
expect(controller.isSelected()).toBeFalsy();
|
|
|
|
});
|
|
|
|
|
|
|
|
|
2014-11-24 23:10:29 +00:00
|
|
|
it("does not expand a node if no context is available", function () {
|
|
|
|
var mockParentContext = jasmine.createSpyObj(
|
|
|
|
"parentContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-11-24 23:10:29 +00:00
|
|
|
),
|
|
|
|
mockChildContext = jasmine.createSpyObj(
|
|
|
|
"childContext",
|
2016-05-19 18:29:13 +00:00
|
|
|
["getParent", "getPath", "getRoot"]
|
2014-11-24 23:10:29 +00:00
|
|
|
),
|
|
|
|
parent = new TestObject("parent", mockParentContext),
|
|
|
|
child = new TestObject("child", undefined);
|
|
|
|
|
|
|
|
mockChildContext.getParent.andReturn(parent);
|
|
|
|
mockChildContext.getPath.andReturn([parent, child]);
|
|
|
|
mockParentContext.getPath.andReturn([parent]);
|
|
|
|
|
|
|
|
// Set up such that we are on, but not at the end of, a path
|
2014-12-04 01:26:02 +00:00
|
|
|
mockScope.ngModel = { selectedObject: child };
|
2014-11-24 23:10:29 +00:00
|
|
|
mockScope.domainObject = parent;
|
|
|
|
mockScope.toggle = jasmine.createSpyObj("toggle", ["setState"]);
|
|
|
|
|
2014-12-04 01:59:37 +00:00
|
|
|
// Invoke the watch with the new selection
|
|
|
|
mockScope.$watch.calls[0].args[1](child);
|
|
|
|
|
|
|
|
expect(mockScope.toggle.setState).not.toHaveBeenCalled();
|
|
|
|
expect(controller.hasBeenExpanded()).toBeFalsy();
|
|
|
|
expect(controller.isSelected()).toBeFalsy();
|
2014-11-24 23:10:29 +00:00
|
|
|
|
|
|
|
});
|
2015-09-21 17:53:45 +00:00
|
|
|
|
|
|
|
it("exposes selected objects in scope", function () {
|
|
|
|
mockScope.domainObject = mockDomainObject;
|
|
|
|
mockScope.ngModel = {};
|
|
|
|
controller.select();
|
|
|
|
expect(mockScope.ngModel.selectedObject)
|
|
|
|
.toEqual(mockDomainObject);
|
|
|
|
});
|
|
|
|
|
|
|
|
it("invokes optional callbacks upon selection", function () {
|
|
|
|
mockScope.parameters =
|
|
|
|
{ callback: jasmine.createSpy('callback') };
|
|
|
|
controller.select();
|
|
|
|
expect(mockScope.parameters.callback).toHaveBeenCalled();
|
|
|
|
});
|
|
|
|
|
2014-11-24 21:39:52 +00:00
|
|
|
});
|
|
|
|
}
|
2015-09-18 21:54:37 +00:00
|
|
|
);
|