alihan/openmct
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed failing tests, and added new tests

Browse Source
This commit is contained in:
Henry
2017-03-26 17:02:00 -07:00
parent 529abcc4b0
commit 4e457f1cf0
13 changed files with 245 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
platform/containment/src/PersistableCompositionPolicy.js
View File

@@ -37,7 +37,6 @@ define(
* Only allow changes to composition if the changes can be saved. This in
* effect prevents selection of objects from the locator that do not
* support persistence.
*
* @param parent
* @param child
* @returns {boolean}

2
platform/containment/test/ComposeActionPolicySpec.js
View File

@@ -78,7 +78,7 @@ define(
expect(mockPolicyService.allow).toHaveBeenCalledWith(
'composition',
mockTypes[0],
mockDomainObjects[0],
mockDomainObjects[1]
);
});

12
platform/containment/test/CompositionModelPolicySpec.js
View File

@@ -4,19 +4,25 @@ define(
function (CompositionModelPolicy) {
describe("The composition model policy", function () {
var mockType,
var mockObject,
mockType,
policy;
beforeEach(function () {
mockType = jasmine.createSpyObj('type', ['getInitialModel']);
mockObject = {
getCapability: function () {
return mockType;
}
};
policy = new CompositionModelPolicy();
});
it("only allows composition for types which will have a composition property", function () {
mockType.getInitialModel.andReturn({});
expect(policy.allow(mockType)).toBeFalsy();
expect(policy.allow(mockObject)).toBeFalsy();
mockType.getInitialModel.andReturn({ composition: [] });
expect(policy.allow(mockType)).toBeTruthy();
expect(policy.allow(mockObject)).toBeTruthy();
});
});

12
platform/containment/test/CompositionMutabilityPolicySpec.js
View File

@@ -25,18 +25,24 @@ define(
function (CompositionMutabilityPolicy) {
describe("The composition mutability policy", function () {
var mockType,
var mockObject,
mockType,
policy;
beforeEach(function () {
mockType = jasmine.createSpyObj('type', ['hasFeature']);
mockObject = {
getCapability: function () {
return mockType;
}
};
policy = new CompositionMutabilityPolicy();
});
it("only allows composition for types which can be created/modified", function () {
expect(policy.allow(mockType)).toBeFalsy();
expect(policy.allow(mockObject)).toBeFalsy();
mockType.hasFeature.andReturn(true);
expect(policy.allow(mockType)).toBeTruthy();
expect(policy.allow(mockObject)).toBeTruthy();
expect(mockType.hasFeature).toHaveBeenCalledWith('creation');
});
});

30
platform/containment/test/CompositionPolicySpec.js
View File

@@ -24,13 +24,18 @@ define(
["../src/CompositionPolicy"],
function (CompositionPolicy) {
describe("Composition policy", function () {
var typeA,
var mockParentObject,
typeA,
typeB,
typeC,
mockChildObject,
policy;
beforeEach(function () {
mockParentObject = jasmine.createSpyObj('domainObject', [
'getCapability'
]);
typeA = jasmine.createSpyObj(
'type A-- the particular kind',
['getKey', 'getDefinition']
@@ -70,27 +75,31 @@ define(
describe('enforces simple containment rules', function () {
it('allows when type matches', function () {
mockParentObject.getCapability.andReturn(typeA);
mockChildObject.getCapability.andReturn(typeA);
expect(policy.allow(typeA, mockChildObject))
expect(policy.allow(mockParentObject, mockChildObject))
.toBeTruthy();
expect(policy.allow(typeB, mockChildObject))
mockParentObject.getCapability.andReturn(typeB);
expect(policy.allow(mockParentObject, mockChildObject))
.toBeTruthy();
mockChildObject.getCapability.andReturn(typeB);
expect(policy.allow(typeB, mockChildObject))
expect(policy.allow(mockParentObject, mockChildObject))
.toBeTruthy();
});
it('disallows when type doesn\'t match', function () {
mockParentObject.getCapability.andReturn(typeA);
mockChildObject.getCapability.andReturn(typeB);
expect(policy.allow(typeA, mockChildObject))
expect(policy.allow(mockParentObject, mockChildObject))
.toBeFalsy();
mockChildObject.getCapability.andReturn(typeC);
expect(policy.allow(typeA, mockChildObject))
expect(policy.allow(mockParentObject, mockChildObject))
.toBeFalsy();
});
@@ -98,8 +107,10 @@ define(
describe('enforces capability-based containment rules', function () {
it('allows when object has capability', function () {
mockParentObject.getCapability.andReturn(typeC);
mockChildObject.hasCapability.andReturn(true);
expect(policy.allow(typeC, mockChildObject))
expect(policy.allow(mockParentObject, mockChildObject))
.toBeTruthy();
expect(mockChildObject.hasCapability)
.toHaveBeenCalledWith('telemetry');
@@ -107,7 +118,10 @@ define(
it('skips when object doesn\'t have capability', function () {
mockChildObject.hasCapability.andReturn(false);
expect(policy.allow(typeC, mockChildObject))
mockParentObject.getCapability.andReturn(typeC);
expect(policy.allow(mockParentObject, mockChildObject))
.toBeFalsy();
expect(mockChildObject.hasCapability)
.toHaveBeenCalledWith('telemetry');

85
platform/containment/test/PersistableCompositionPolicySpec.js Normal file
View File

@@ -0,0 +1,85 @@
/*****************************************************************************
* Open MCT, Copyright (c) 2014-2016, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* Open MCT 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 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.
*****************************************************************************/
define(
["../src/PersistableCompositionPolicy"],
function (PersistableCompositionPolicy) {
describe("Persistable Composition policy", function () {
var objectAPI;
var mockOpenMCT;
var persistableCompositionPolicy;
var mockParent;
var mockChild;
var mockEditorCapability;
beforeEach(function () {
objectAPI = jasmine.createSpyObj('objectsAPI', [
'getProvider'
]);
mockOpenMCT = {
objects: objectAPI
};
mockParent = jasmine.createSpyObj('domainObject', [
'hasCapability',
'getCapability',
'getId'
]);
mockParent.hasCapability.andReturn(true);
mockParent.getId.andReturn('someNamespace:someId');
mockChild = {};
mockEditorCapability = jasmine.createSpyObj('domainObject', [
'isEditContextRoot'
]);
mockParent.getCapability.andReturn(mockEditorCapability);
objectAPI.getProvider.andReturn({
save: function () {}
});
persistableCompositionPolicy = new PersistableCompositionPolicy(mockOpenMCT);
});
//Parent
// - getCapability ('editor')
// - isEditContextRoot
// - openMct.objects.getProvider
it("Does not allow composition for objects that are not persistable", function () {
mockEditorCapability.isEditContextRoot.andReturn(false);
expect(persistableCompositionPolicy.allow(mockParent, mockChild)).toBe(true);
objectAPI.getProvider.andReturn({});
expect(persistableCompositionPolicy.allow(mockParent, mockChild)).toBe(false);
});
it("Always allows composition of objects in edit mode to support object creation", function () {
mockEditorCapability.isEditContextRoot.andReturn(true);
expect(persistableCompositionPolicy.allow(mockParent, mockChild)).toBe(true);
expect(objectAPI.getProvider).not.toHaveBeenCalled();
mockEditorCapability.isEditContextRoot.andReturn(false);
expect(persistableCompositionPolicy.allow(mockParent, mockChild)).toBe(true);
expect(objectAPI.getProvider).toHaveBeenCalled();
});
});
}
);