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

Removed contextualization warning. Removed now redundant Contextualize service. Fixes #1498

Browse Source
This commit is contained in:
Henry
2017-03-31 15:16:20 -07:00
parent 4d6a0d4931
commit a867cd6be0
11 changed files with 30 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
platform/core/bundle.js
View File

@@ -49,7 +49,6 @@ define([
"./src/services/Now",
"./src/services/Throttle",
"./src/services/Topic",
"./src/services/Contextualize",
"./src/services/Instantiate",
'legacyRegistry'
], function (
@@ -81,7 +80,6 @@ define([
Now,
Throttle,
Topic,
Contextualize,
Instantiate,
legacyRegistry
) {
@@ -284,8 +282,7 @@ define([
"key": "composition",
"implementation": CompositionCapability,
"depends": [
"$injector",
"contextualize"
"$injector"
]
},
{
@@ -380,13 +377,6 @@ define([
"$log"
]
},
{
"key": "contextualize",
"implementation": Contextualize,
"depends": [
"$log"
]
},
{
"key": "instantiate",
"implementation": Instantiate,

9
platform/core/src/capabilities/CompositionCapability.js
View File

@@ -24,7 +24,8 @@
* Module defining CompositionCapability. Created by vwoeltje on 11/7/14.
*/
define(
function () {
['./ContextualDomainObject'],
function (ContextualDomainObject) {
/**
* Composition capability. A domain object's composition is the set of
@@ -38,13 +39,12 @@ define(
* @constructor
* @implements {Capability}
*/
function CompositionCapability($injector, contextualize, domainObject) {
function CompositionCapability($injector, domainObject) {
// Get a reference to the object service from $injector
this.injectObjectService = function () {
this.objectService = $injector.get("objectService");
};
this.contextualize = contextualize;
this.domainObject = domainObject;
}
@@ -115,7 +115,6 @@ define(
CompositionCapability.prototype.invoke = function () {
var domainObject = this.domainObject,
model = domainObject.getModel(),
contextualize = this.contextualize,
ids;
// Then filter out non-existent objects,
@@ -125,7 +124,7 @@ define(
return ids.filter(function (id) {
return objects[id];
}).map(function (id) {
return contextualize(objects[id], domainObject);
return new ContextualDomainObject(objects[id], domainObject);
});
}

10
platform/core/src/capabilities/InstantiationCapability.js
View File

@@ -21,8 +21,8 @@
*****************************************************************************/
define(
[],
function () {
['./ContextualDomainObject'],
function (ContextualDomainObject) {
/**
* Implements the `instantiation` capability. This allows new domain
@@ -70,11 +70,7 @@ define(
var newObject = this.instantiateFn(model, id);
this.contextualizeFn = this.contextualizeFn ||
this.$injector.get("contextualize");
return this.contextualizeFn(newObject, this.domainObject);
return new ContextualDomainObject(newObject, this.domainObject);
};
/**

82
platform/core/src/services/Contextualize.js
View File

@@ -1,82 +0,0 @@
/*****************************************************************************
* 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(
['../capabilities/ContextualDomainObject'],
function (ContextualDomainObject) {
/**
* Wrap a domain object such that it has a `context` capability
* referring to a specific parent.
*
* Usage:
*
* contextualize(domainObject, parentObject)
*
* Attempting to contextualize an object with a parent that does
* not include that object in its composition may have
* unpredictable results; a warning will be logged if this occurs.
*
* @returns {Function}
* @memberof platform/core
*/
function Contextualize($log) {
function validate(id, parentObject) {
var model = parentObject && parentObject.getModel(),
composition = (model || {}).composition || [];
if (composition.indexOf(id) === -1) {
$log.warn([
"Attempted to contextualize",
id,
"in",
parentObject && parentObject.getId(),
"but that object does not contain",
id,
"in its composition.",
"Unexpected behavior may follow."
].join(" "));
}
}
/**
* Contextualize this domain object.
* @param {DomainObject} domainObject the domain object
* to wrap with a context
* @param {DomainObject} parentObject the domain object
* which should appear as the contextual parent
*/
return function (domainObject, parentObject) {
// Don't validate while editing; consistency is not
// necessarily expected due to unsaved changes.
var editor = domainObject.getCapability('editor');
if (!editor || !editor.inEditContext()) {
validate(domainObject.getId(), parentObject);
}
return new ContextualDomainObject(domainObject, parentObject);
};
}
return Contextualize;
}
);

9
platform/core/test/capabilities/CompositionCapabilitySpec.js
View File

@@ -41,7 +41,6 @@ define(
describe("The composition capability", function () {
var mockDomainObject,
mockInjector,
mockContextualize,
mockObjectService,
composition;
@@ -72,19 +71,11 @@ define(
return (name === "objectService") && mockObjectService;
}
};
mockContextualize = jasmine.createSpy('contextualize');
// Provide a minimal (e.g. no error-checking) implementation
// of contextualize for simplicity
mockContextualize.andCallFake(function (domainObject, parentObject) {
return new ContextualDomainObject(domainObject, parentObject);
});
mockObjectService.getObjects.andReturn(mockPromise([]));
composition = new CompositionCapability(
mockInjector,
mockContextualize,
mockDomainObject
);
});

13
platform/core/test/capabilities/InstantiationCapabilitySpec.js
View File

@@ -28,7 +28,6 @@ define(
var mockInjector,
mockIdentifierService,
mockInstantiate,
mockContextualize,
mockIdentifier,
mockNow,
mockDomainObject,
@@ -37,7 +36,6 @@ define(
beforeEach(function () {
mockInjector = jasmine.createSpyObj("$injector", ["get"]);
mockInstantiate = jasmine.createSpy("instantiate");
mockContextualize = jasmine.createSpy("contextualize");
mockIdentifierService = jasmine.createSpyObj(
'identifierService',
['parse', 'generate']
@@ -53,8 +51,7 @@ define(
mockInjector.get.andCallFake(function (key) {
return {
'instantiate': mockInstantiate,
'contextualize': mockContextualize
'instantiate': mockInstantiate
}[key];
});
mockIdentifierService.parse.andReturn(mockIdentifier);
@@ -85,18 +82,12 @@ define(
'hasCapability'
]), testModel = { someKey: "some value" };
mockInstantiate.andReturn(mockDomainObj);
mockContextualize.andCallFake(function (x) {
return x;
});
expect(instantiation.instantiate(testModel))
.toBe(mockDomainObj);
instantiation.instantiate(testModel);
expect(mockInstantiate)
.toHaveBeenCalledWith({
someKey: "some value",
modified: mockNow()
}, jasmine.any(String));
expect(mockContextualize)
.toHaveBeenCalledWith(mockDomainObj, mockDomainObject);
});
});

103
platform/core/test/services/ContextualizeSpec.js
View File

@@ -1,103 +0,0 @@
/*****************************************************************************
* 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/services/Contextualize"],
function (Contextualize) {
var DOMAIN_OBJECT_METHODS = [
'getId',
'getModel',
'getCapability',
'hasCapability',
'useCapability'
];
describe("The 'contextualize' service", function () {
var mockLog,
mockDomainObject,
mockParentObject,
mockEditor,
testParentModel,
contextualize;
beforeEach(function () {
testParentModel = { composition: ["abc"] };
mockLog = jasmine.createSpyObj(
"$log",
["error", "warn", "info", "debug"]
);
mockDomainObject =
jasmine.createSpyObj('domainObject', DOMAIN_OBJECT_METHODS);
mockParentObject =
jasmine.createSpyObj('parentObject', DOMAIN_OBJECT_METHODS);
mockEditor =
jasmine.createSpyObj('editor', ['inEditContext']);
mockDomainObject.getId.andReturn("abc");
mockDomainObject.getModel.andReturn({});
mockParentObject.getId.andReturn("parent");
mockParentObject.getModel.andReturn(testParentModel);
mockEditor.inEditContext.andReturn(false);
mockDomainObject.getCapability.andCallFake(function (c) {
return c === 'editor' && mockEditor;
});
contextualize = new Contextualize(mockLog);
});
it("attaches a context capability", function () {
var contextualizedObject =
contextualize(mockDomainObject, mockParentObject);
expect(contextualizedObject.getId()).toEqual("abc");
expect(contextualizedObject.getCapability("context"))
.toBeDefined();
expect(contextualizedObject.getCapability("context").getParent())
.toBe(mockParentObject);
});
it("issues a warning if composition does not match", function () {
// Precondition - normally it should not issue a warning
contextualize(mockDomainObject, mockParentObject);
expect(mockLog.warn).not.toHaveBeenCalled();
testParentModel.composition = ["xyz"];
contextualize(mockDomainObject, mockParentObject);
expect(mockLog.warn).toHaveBeenCalled();
});
it("does not issue warnings for objects being edited", function () {
mockEditor.inEditContext.andReturn(true);
testParentModel.composition = ["xyz"];
contextualize(mockDomainObject, mockParentObject);
expect(mockLog.warn).not.toHaveBeenCalled();
});
});
}
);